Fix StartOS 0.4 TypeScript packaging to match SDK API

2026-04-09 15:10:44 -05:00
parent 68ec875ee7
commit 8298c083c7
3436 changed files with 867051 additions and 92 deletions
@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partialDiff = partialDiff;
+exports.deepMerge = deepMerge;
+/**
+ * Computes the partial difference between two values.
+ * Returns `undefined` if the values are equal, or `{ diff }` containing only the changed parts.
+ * For arrays, the diff contains only items in `next` that have no deep-equal counterpart in `prev`.
+ * For objects, the diff contains only keys whose values changed.
+ *
+ * @param prev - The original value
+ * @param next - The updated value
+ * @returns An object containing the diff, or `undefined` if the values are equal
+ */
+function partialDiff(prev, next) {
+    if (prev === next) {
+        return;
+    }
+    else if (Array.isArray(prev) && Array.isArray(next)) {
+        const res = { diff: [] };
+        for (let newItem of next) {
+            let anyEq = false;
+            for (let oldItem of prev) {
+                if (!partialDiff(oldItem, newItem)) {
+                    anyEq = true;
+                    break;
+                }
+            }
+            if (!anyEq) {
+                res.diff.push(newItem);
+            }
+        }
+        if (res.diff.length) {
+            return res;
+        }
+        else {
+            return;
+        }
+    }
+    else if (typeof prev === 'object' && typeof next === 'object') {
+        if (prev === null || next === null)
+            return { diff: next };
+        const res = { diff: {} };
+        const keys = Object.keys(next);
+        for (let key in prev) {
+            if (!keys.includes(key))
+                keys.push(key);
+        }
+        for (let key of keys) {
+            const diff = partialDiff(prev[key], next[key]);
+            if (diff) {
+                res.diff[key] = diff.diff;
+            }
+        }
+        if (Object.keys(res.diff).length) {
+            return res;
+        }
+        else {
+            return;
+        }
+    }
+    else {
+        return { diff: next };
+    }
+}
+/**
+ * Deeply merges multiple values together. Objects are merged key-by-key recursively.
+ * Arrays are merged by appending items that are not already present (by deep equality).
+ * Primitives are resolved by taking the last argument.
+ *
+ * @param args - The values to merge, applied left to right
+ * @returns The merged result
+ */
+function deepMerge(...args) {
+    const lastItem = args[args.length - 1];
+    if (typeof lastItem !== 'object' || !lastItem)
+        return lastItem;
+    if (Array.isArray(lastItem))
+        return deepMergeList(...args.filter((x) => Array.isArray(x)));
+    return deepMergeObject(...args.filter((x) => typeof x === 'object' && x && !Array.isArray(x)));
+}
+function deepMergeList(...args) {
+    const res = [];
+    for (let arg of args) {
+        for (let item of arg) {
+            if (!res.some((x) => !partialDiff(x, item))) {
+                res.push(item);
+            }
+        }
+    }
+    return res;
+}
+function deepMergeObject(...args) {
+    const lastItem = args[args.length - 1];
+    if (args.length === 0)
+        return lastItem;
+    if (args.length === 1)
+        args.unshift({});
+    const allKeys = new Set(args.flatMap((x) => Object.keys(x)));
+    for (const key of allKeys) {
+        const filteredValues = args.flatMap((x) => key in x ? [x[key]] : []);
+        args[0][key] = deepMerge(...filteredValues);
+    }
+    return args[0];
+}
+//# sourceMappingURL=deepMerge.js.map