chore(release): 2.0.0 [CI SKIP]

BREAKING CHANGE: All usage of *Patch functions must now store the result and call .unpatch()
unpatch() has been removed.

CHANGELOG.md

@@ -1,3 +1,23 @@
+# [2.0.0](https://github.com/SteamDeckHomebrew/decky-frontend-lib/compare/v1.8.3...v2.0.0) (2022-09-04)
+
+
+### Features
+
+* **patcher:** rewrite to support multiple patches ([076d9eb](https://github.com/SteamDeckHomebrew/decky-frontend-lib/commit/076d9eb5e8f22bfa49afc242608698da2ded50e4))
+
+
+### BREAKING CHANGES
+
+* **patcher:** All usage of *Patch functions must now store the result and call .unpatch()
+unpatch() has been removed.
+
+## [1.8.3](https://github.com/SteamDeckHomebrew/decky-frontend-lib/compare/v1.8.2...v1.8.3) (2022-09-03)
+
+
+### Bug Fixes
+
+* **plugin:** Export ServerResponse for use in plugin-loader.tsx ([#20](https://github.com/SteamDeckHomebrew/decky-frontend-lib/issues/20)) ([d01c7b3](https://github.com/SteamDeckHomebrew/decky-frontend-lib/commit/d01c7b3904c12142a58f78cbb93a4c1ecb438280))
+
 ## [1.8.2](https://github.com/SteamDeckHomebrew/decky-frontend-lib/compare/v1.8.1...v1.8.2) (2022-08-28)
 
 

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "decky-frontend-lib",
-  "version": "1.8.2",
+  "version": "2.0.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "decky-frontend-lib",
-      "version": "1.8.2",
+      "version": "2.0.0",
       "license": "GPL-2.0-or-later",
       "dependencies": {
         "minimist": "^1.2.6"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "decky-frontend-lib",
-  "version": "1.8.2",
+  "version": "2.0.0",
   "description": "A library for building decky plugins",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/plugin.tsx

@@ -18,7 +18,7 @@ interface ServerResponseError {
   result: string;
 }
 
-type ServerResponse<TRes> = ServerResponseSuccess<TRes> | ServerResponseError;
+export type ServerResponse<TRes> = ServerResponseSuccess<TRes> | ServerResponseError;
 
 type RoutePatch = (route: RouteProps) => RouteProps;
 

src/utils/index.ts

@@ -0,0 +1,10 @@
+export * from "./patcher";
+export * from "./react";
+
+export function joinClassNames(...classes: string[]): string {
+    return classes.join(" ");
+}
+
+export function sleep(ms: number) {
+    return new Promise(res => setTimeout(res, ms));
+}

src/utils/patcher.ts

@@ -0,0 +1,112 @@
+// TODO: implement storing patches as an option so we can offer unpatchAll selectively
+// Return this in a replacePatch to call the original method (can still modify args).
+export let callOriginal = Symbol("DECKY_CALL_ORIGINAL");
+
+export interface PatchOptions {
+    singleShot?: boolean
+}
+
+type GenericPatchHandler = (args: any[], ret?: any) => any;
+
+export interface Patch {
+    original: Function;
+    property: string;
+    object: any;
+    patchedFunction: any;
+    hasUnpatched: boolean;
+    handler: GenericPatchHandler;
+
+    unpatch: () => void
+};
+
+// let patches = new Set<Patch>();
+
+export function beforePatch(object: any, property: string, handler: (args: any[]) => any, options: PatchOptions = {}): Patch {
+    const orig = object[property];
+    object[property] = function (...args: any[]) {
+        handler.call(this, args);
+        const ret = patch.original.call(this, ...args);
+        if (options.singleShot) {
+            patch.unpatch();
+        }
+        return ret;
+    }
+    const patch = processPatch(object, property, handler, object[property], orig);
+    return patch;
+}
+
+export function afterPatch(object: any, property: string, handler: (args: any[], ret: any) => any, options: PatchOptions = {}): Patch {
+    const orig = object[property];
+    object[property] = function (...args: any[]) {
+        let ret = patch.original.call(this, ...args);
+        ret = handler.call(this, args, ret);
+        if (options.singleShot) {
+            patch.unpatch();
+        }
+        return ret;
+    }
+    const patch = processPatch(object, property, handler, object[property], orig);
+    return patch;
+}
+
+export function replacePatch(object: any, property: string, handler: (args: any[]) => any, options: PatchOptions = {}): Patch {
+    const orig = object[property];
+    object[property] = function (...args: any[]) {
+        const ret = handler.call(this, args);
+        if (ret == callOriginal) return patch.original.call(this, ...args);
+        if (options.singleShot) {
+            patch.unpatch();
+        }
+        return ret;
+    };
+    const patch = processPatch(object, property, handler, object[property], orig);
+    return patch;
+}
+
+function processPatch(object: any, property: any, handler: GenericPatchHandler, patchedFunction: any, original: any): Patch {
+    // Assign all props of original function to new one
+    Object.assign(object[property], original);
+    // Allow toString webpack filters to continue to work
+    object[property].toString = () => original.toString();
+
+    // HACK: for compatibility, remove when all plugins are using new patcher
+    Object.defineProperty(object[property], "__deckyOrig", {
+        get: () => patch.original,
+        set: (val: any) => patch.original = val
+    })
+
+    // Build a Patch object of this patch
+    const patch: Patch = {
+        object,
+        property,
+        handler,
+        patchedFunction,
+        original,
+        hasUnpatched: false,
+        unpatch: () => unpatch(patch)
+    };
+
+    object[property].__deckyPatch = patch;
+
+    return patch;
+}
+
+function unpatch(patch: Patch): void {
+    const { object, property, handler, patchedFunction, original } = patch;
+    if (patch.hasUnpatched) throw new Error("Function is already unpatched.")
+    let realProp = property;
+    let realObject = object;
+    console.debug("[Patcher] unpatching", {realObject, realProp, object, property, handler, patchedFunction, original, isEqual: realObject[realProp] === patchedFunction})
+
+    // If another patch has been applied to this function after this one, move down until we find the correct patch
+    while (realObject[realProp] && realObject[realProp] !== patchedFunction) {
+        realObject = realObject[realProp].__deckyPatch;
+        realProp = "original";
+        console.debug("[Patcher] moved to next", {realObject, realProp, object, property, handler, patchedFunction, original, isEqual: realObject[realProp] === patchedFunction})
+    }
+
+    realObject[realProp] = realObject[realProp].__deckyPatch.original
+
+    patch.hasUnpatched = true;
+    console.debug("[Patcher] unpatched", {realObject, realProp, object, property, handler, patchedFunction, original, isEqual: realObject[realProp] === patchedFunction})
+}

src/utils/react.ts

@@ -42,62 +42,6 @@ export function fakeRenderComponent(fun: Function): any {
     return res;
 }
 
-export interface PatchOptions {
-  singleShot?: boolean
-}
-
-export function beforePatch(obj: any, name: string, fnc: (args: any[]) => any, options: PatchOptions = {}): void {
-    const orig = obj[name];
-    obj[name] = function (...args: any[]) {
-        fnc.call(this, args);
-        const ret = orig.call(this, ...args);
-        if (options.singleShot) {
-            unpatch(obj, name);
-        }
-        return ret;
-    }
-    Object.assign(obj[name], orig);
-    obj[name].toString = () => orig.toString();
-    obj[name].__deckyOrig = orig;
-}
-
-export function afterPatch(obj: any, name: string, fnc: (args: any[], ret: any) => any, options: PatchOptions = {}): void {
-    const orig = obj[name];
-    obj[name] = function (...args: any[]) {
-        let ret = orig.call(this, ...args);
-        ret = fnc.call(this, args, ret);
-        if (options.singleShot) {
-            unpatch(obj, name);
-        }
-        return ret;
-    }
-    Object.assign(obj[name], orig);
-    obj[name].toString = () => orig.toString();
-    obj[name].__deckyOrig = orig;
-}
-
-export function replacePatch(obj: any, name: string, fnc: (args: any[]) => any, options: PatchOptions = {}): void {
-    const orig = obj[name];
-    obj[name] = function (...args: any[]) {
-      let ret = fnc.call(this, args);
-      if (ret == 'CALL_ORIGINAL') ret = orig.call(this, ...args);
-      if (options.singleShot) {
-          unpatch(obj, name);
-      }
-      return ret;
-    };
-    Object.assign(obj[name], orig);
-    obj[name].toString = () => orig.toString();
-    obj[name].__deckyOrig = orig;
-}
-
-// TODO allow one method to be patched and unpatched multiple times independently using IDs in a Map or something
-export function unpatch(obj: any, name: any): void {
-    if (obj[name].__deckyOrig !== undefined) {
-        obj[name] = obj[name].__deckyOrig;
-    }
-}
-
 export function wrapReactType(node: any, prop: any = 'type') {
     return node[prop] = {...node[prop]};
 }
@@ -112,14 +56,6 @@ export function getReactInstance(o: HTMLElement | Element | Node) {
     return o[Object.keys(o).find(k => k.startsWith('__reactInternalInstance')) as string]
 }
 
-export function joinClassNames(...classes: string[]): string {
-    return classes.join(" ");
-}
-
-export function sleep(ms: number) {
-    return new Promise(res => setTimeout(res, ms));
-}
-
 // Based on https://github.com/GooseMod/GooseMod/blob/9ef146515a9e59ed4e25665ed365fd72fc0dcf23/src/util/react.js#L20
 export interface findInTreeOpts {
     walkable?: string[],
@@ -147,4 +83,4 @@ export const findInTree = (parent: any, filter: findInTreeFilter, opts: findInTr
   
 export const findInReactTree = (node: any, filter: findInTreeFilter) => findInTree(node, filter, { // Specialised findInTree for React nodes
     walkable: [ 'props', 'children', 'child', 'sibling' ]
-});
+});