@player-devtools/utils 0.0.7--canary.8.483

package/dist/cjs/index.cjs

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/devtools/utils/core/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  dsetAssign: () => dsetAssign
+});
+module.exports = __toCommonJS(src_exports);
+function deepAssign(target, source, merge = false) {
+  if (Array.isArray(target) && Array.isArray(source)) {
+    while (!merge && target.length > source.length) target.pop();
+    for (const [index, item] of source.entries()) {
+      target[index] = deepAssign(target[index], item, merge);
+    }
+  } else if (target && typeof target === "object" && source && typeof source === "object") {
+    const record = target;
+    if (!merge)
+      for (const key of Object.keys(target)) {
+        if (!(key in source)) delete record[key];
+      }
+    for (const [key, item] of Object.entries(source)) {
+      record[key] = deepAssign(record[key], item, merge);
+    }
+  } else {
+    return source;
+  }
+  return target;
+}
+function dsetAssign(obj, keys, value, merge = false) {
+  const key = keys[keys.length - 1];
+  if (!key) throw Error("Unable to assign at path containing undefined keys");
+  const target = keys.slice(0, -1).reduce(
+    (acc, key2) => acc[key2] ?? (acc[key2] = {}),
+    obj
+  );
+  target[key] = deepAssign(target[key], value, merge);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dsetAssign
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/devtools/utils/core/src/index.ts"],"sourcesContent":["/**\n * Recursively assigns the contents of `source` into `target`, preserving\n * existing object and array references to maintain key insertion order.\n *\n * - **Objects**: keys present in `target` but absent in `source` are deleted\n *   (unless `merge` is true), then each source entry is recursed into.\n * - **Arrays**: target is truncated or extended to match source length\n *   (unless `merge` is true), then each element is recursed into.\n * - **Primitives / type mismatch**: source is returned directly; the caller\n *   is responsible for assigning the return value.\n *\n * @param target - The existing value to assign into.\n * @param source - The new value to assign from.\n * @param merge - When true, stale keys and excess array elements are preserved\n *   rather than deleted. Defaults to false.\n * @returns The mutated `target`, or `source` if types are incompatible.\n */\nfunction deepAssign<T, V>(target: T, source: V, merge: boolean = false) {\n  if (Array.isArray(target) && Array.isArray(source)) {\n    while (!merge && target.length > source.length) target.pop();\n    // recurse and assign new values\n    for (const [index, item] of source.entries()) {\n      target[index] = deepAssign(target[index], item, merge);\n    }\n  } else if (\n    target &&\n    typeof target === \"object\" &&\n    source &&\n    typeof source === \"object\"\n  ) {\n    const record = target as Record<string, unknown>;\n\n    // clear stale keys\n    if (!merge)\n      for (const key of Object.keys(target)) {\n        if (!(key in source)) delete record[key];\n      }\n    // recurse and assign new values\n    for (const [key, item] of Object.entries(source)) {\n      record[key] = deepAssign(record[key], item, merge);\n    }\n  } else {\n    // new data doesn't match the types, so there is no referential equality to retain\n    return source;\n  }\n\n  return target;\n}\n\ntype Index = string | number;\n\n/**\n * Deep-sets a value at a key path on an object, preserving existing nested\n * object and array references to maintain key insertion order.\n *\n * Intermediate objects are auto-vivified as needed. The final assignment is\n * handled by {@link deepAssign}, which mutates the existing value in place\n * rather than replacing it wholesale.\n *\n * @param obj - The root object to assign into.\n * @param keys - Path of keys leading to the target location.\n * @param value - The value to assign at the path.\n * @param merge - When true, stale keys and excess array elements are preserved\n *   rather than deleted. Defaults to false.\n * @throws If `keys` is empty or contains an undefined key.\n *\n * @see {@link https://github.com/lukeed/dset} for the original dset implementation that inspired this API\n */\nexport function dsetAssign<V>(\n  obj: Record<Index, unknown>,\n  keys: Array<Index>,\n  value: V,\n  merge: boolean = false,\n): void {\n  const key = keys[keys.length - 1];\n  if (!key) throw Error(\"Unable to assign at path containing undefined keys\");\n\n  // Walk the path, auto-vivifying intermediate objects when necessary\n  const target = keys\n    .slice(0, -1)\n    .reduce(\n      (acc, key) => (acc[key] ??= {}) as Record<string | number, unknown>,\n      obj,\n    );\n\n  // Deep assign the value into the target object for key\n  target[key] = deepAssign(target[key], value, merge);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,SAAS,WAAiB,QAAW,QAAW,QAAiB,OAAO;AACtE,MAAI,MAAM,QAAQ,MAAM,KAAK,MAAM,QAAQ,MAAM,GAAG;AAClD,WAAO,CAAC,SAAS,OAAO,SAAS,OAAO,OAAQ,QAAO,IAAI;AAE3D,eAAW,CAAC,OAAO,IAAI,KAAK,OAAO,QAAQ,GAAG;AAC5C,aAAO,KAAK,IAAI,WAAW,OAAO,KAAK,GAAG,MAAM,KAAK;AAAA,IACvD;AAAA,EACF,WACE,UACA,OAAO,WAAW,YAClB,UACA,OAAO,WAAW,UAClB;AACA,UAAM,SAAS;AAGf,QAAI,CAAC;AACH,iBAAW,OAAO,OAAO,KAAK,MAAM,GAAG;AACrC,YAAI,EAAE,OAAO,QAAS,QAAO,OAAO,GAAG;AAAA,MACzC;AAEF,eAAW,CAAC,KAAK,IAAI,KAAK,OAAO,QAAQ,MAAM,GAAG;AAChD,aAAO,GAAG,IAAI,WAAW,OAAO,GAAG,GAAG,MAAM,KAAK;AAAA,IACnD;AAAA,EACF,OAAO;AAEL,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAqBO,SAAS,WACd,KACA,MACA,OACA,QAAiB,OACX;AACN,QAAM,MAAM,KAAK,KAAK,SAAS,CAAC;AAChC,MAAI,CAAC,IAAK,OAAM,MAAM,oDAAoD;AAG1E,QAAM,SAAS,KACZ,MAAM,GAAG,EAAE,EACX;AAAA,IACC,CAAC,KAAKA,SAAS,IAAAA,UAAA,IAAAA,QAAa,CAAC;AAAA,IAC7B;AAAA,EACF;AAGF,SAAO,GAAG,IAAI,WAAW,OAAO,GAAG,GAAG,OAAO,KAAK;AACpD;","names":["key"]}

package/dist/index.legacy-esm.js

@@ -0,0 +1,34 @@
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/devtools/utils/core/src/index.ts
+function deepAssign(target, source, merge = false) {
+  if (Array.isArray(target) && Array.isArray(source)) {
+    while (!merge && target.length > source.length) target.pop();
+    for (const [index, item] of source.entries()) {
+      target[index] = deepAssign(target[index], item, merge);
+    }
+  } else if (target && typeof target === "object" && source && typeof source === "object") {
+    const record = target;
+    if (!merge)
+      for (const key of Object.keys(target)) {
+        if (!(key in source)) delete record[key];
+      }
+    for (const [key, item] of Object.entries(source)) {
+      record[key] = deepAssign(record[key], item, merge);
+    }
+  } else {
+    return source;
+  }
+  return target;
+}
+function dsetAssign(obj, keys, value, merge = false) {
+  const key = keys[keys.length - 1];
+  if (!key) throw Error("Unable to assign at path containing undefined keys");
+  const target = keys.slice(0, -1).reduce(
+    (acc, key2) => acc[key2] ?? (acc[key2] = {}),
+    obj
+  );
+  target[key] = deepAssign(target[key], value, merge);
+}
+export {
+  dsetAssign
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs

@@ -0,0 +1,34 @@
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/devtools/utils/core/src/index.ts
+function deepAssign(target, source, merge = false) {
+  if (Array.isArray(target) && Array.isArray(source)) {
+    while (!merge && target.length > source.length) target.pop();
+    for (const [index, item] of source.entries()) {
+      target[index] = deepAssign(target[index], item, merge);
+    }
+  } else if (target && typeof target === "object" && source && typeof source === "object") {
+    const record = target;
+    if (!merge)
+      for (const key of Object.keys(target)) {
+        if (!(key in source)) delete record[key];
+      }
+    for (const [key, item] of Object.entries(source)) {
+      record[key] = deepAssign(record[key], item, merge);
+    }
+  } else {
+    return source;
+  }
+  return target;
+}
+function dsetAssign(obj, keys, value, merge = false) {
+  const key = keys[keys.length - 1];
+  if (!key) throw Error("Unable to assign at path containing undefined keys");
+  const target = keys.slice(0, -1).reduce(
+    (acc, key2) => acc[key2] ?? (acc[key2] = {}),
+    obj
+  );
+  target[key] = deepAssign(target[key], value, merge);
+}
+export {
+  dsetAssign
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/devtools/utils/core/src/index.ts"],"sourcesContent":["/**\n * Recursively assigns the contents of `source` into `target`, preserving\n * existing object and array references to maintain key insertion order.\n *\n * - **Objects**: keys present in `target` but absent in `source` are deleted\n *   (unless `merge` is true), then each source entry is recursed into.\n * - **Arrays**: target is truncated or extended to match source length\n *   (unless `merge` is true), then each element is recursed into.\n * - **Primitives / type mismatch**: source is returned directly; the caller\n *   is responsible for assigning the return value.\n *\n * @param target - The existing value to assign into.\n * @param source - The new value to assign from.\n * @param merge - When true, stale keys and excess array elements are preserved\n *   rather than deleted. Defaults to false.\n * @returns The mutated `target`, or `source` if types are incompatible.\n */\nfunction deepAssign<T, V>(target: T, source: V, merge: boolean = false) {\n  if (Array.isArray(target) && Array.isArray(source)) {\n    while (!merge && target.length > source.length) target.pop();\n    // recurse and assign new values\n    for (const [index, item] of source.entries()) {\n      target[index] = deepAssign(target[index], item, merge);\n    }\n  } else if (\n    target &&\n    typeof target === \"object\" &&\n    source &&\n    typeof source === \"object\"\n  ) {\n    const record = target as Record<string, unknown>;\n\n    // clear stale keys\n    if (!merge)\n      for (const key of Object.keys(target)) {\n        if (!(key in source)) delete record[key];\n      }\n    // recurse and assign new values\n    for (const [key, item] of Object.entries(source)) {\n      record[key] = deepAssign(record[key], item, merge);\n    }\n  } else {\n    // new data doesn't match the types, so there is no referential equality to retain\n    return source;\n  }\n\n  return target;\n}\n\ntype Index = string | number;\n\n/**\n * Deep-sets a value at a key path on an object, preserving existing nested\n * object and array references to maintain key insertion order.\n *\n * Intermediate objects are auto-vivified as needed. The final assignment is\n * handled by {@link deepAssign}, which mutates the existing value in place\n * rather than replacing it wholesale.\n *\n * @param obj - The root object to assign into.\n * @param keys - Path of keys leading to the target location.\n * @param value - The value to assign at the path.\n * @param merge - When true, stale keys and excess array elements are preserved\n *   rather than deleted. Defaults to false.\n * @throws If `keys` is empty or contains an undefined key.\n *\n * @see {@link https://github.com/lukeed/dset} for the original dset implementation that inspired this API\n */\nexport function dsetAssign<V>(\n  obj: Record<Index, unknown>,\n  keys: Array<Index>,\n  value: V,\n  merge: boolean = false,\n): void {\n  const key = keys[keys.length - 1];\n  if (!key) throw Error(\"Unable to assign at path containing undefined keys\");\n\n  // Walk the path, auto-vivifying intermediate objects when necessary\n  const target = keys\n    .slice(0, -1)\n    .reduce(\n      (acc, key) => (acc[key] ??= {}) as Record<string | number, unknown>,\n      obj,\n    );\n\n  // Deep assign the value into the target object for key\n  target[key] = deepAssign(target[key], value, merge);\n}\n"],"mappings":";AAiBA,SAAS,WAAiB,QAAW,QAAW,QAAiB,OAAO;AACtE,MAAI,MAAM,QAAQ,MAAM,KAAK,MAAM,QAAQ,MAAM,GAAG;AAClD,WAAO,CAAC,SAAS,OAAO,SAAS,OAAO,OAAQ,QAAO,IAAI;AAE3D,eAAW,CAAC,OAAO,IAAI,KAAK,OAAO,QAAQ,GAAG;AAC5C,aAAO,KAAK,IAAI,WAAW,OAAO,KAAK,GAAG,MAAM,KAAK;AAAA,IACvD;AAAA,EACF,WACE,UACA,OAAO,WAAW,YAClB,UACA,OAAO,WAAW,UAClB;AACA,UAAM,SAAS;AAGf,QAAI,CAAC;AACH,iBAAW,OAAO,OAAO,KAAK,MAAM,GAAG;AACrC,YAAI,EAAE,OAAO,QAAS,QAAO,OAAO,GAAG;AAAA,MACzC;AAEF,eAAW,CAAC,KAAK,IAAI,KAAK,OAAO,QAAQ,MAAM,GAAG;AAChD,aAAO,GAAG,IAAI,WAAW,OAAO,GAAG,GAAG,MAAM,KAAK;AAAA,IACnD;AAAA,EACF,OAAO;AAEL,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAqBO,SAAS,WACd,KACA,MACA,OACA,QAAiB,OACX;AACN,QAAM,MAAM,KAAK,KAAK,SAAS,CAAC;AAChC,MAAI,CAAC,IAAK,OAAM,MAAM,oDAAoD;AAG1E,QAAM,SAAS,KACZ,MAAM,GAAG,EAAE,EACX;AAAA,IACC,CAAC,KAAKA,SAAS,IAAAA,UAAA,IAAAA,QAAa,CAAC;AAAA,IAC7B;AAAA,EACF;AAGF,SAAO,GAAG,IAAI,WAAW,OAAO,GAAG,GAAG,OAAO,KAAK;AACpD;","names":["key"]}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "types"
+  ],
+  "name": "@player-devtools/utils",
+  "version": "0.0.7--canary.8.483",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/index.legacy-esm.js",
+  "types": "types/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    "./dist/index.css": "./dist/index.css",
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/cjs/index.cjs"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.6.2"
+  },
+  "peerDependencies": {}
+}

package/src/index.ts

@@ -0,0 +1,88 @@
+/**
+ * Recursively assigns the contents of `source` into `target`, preserving
+ * existing object and array references to maintain key insertion order.
+ *
+ * - **Objects**: keys present in `target` but absent in `source` are deleted
+ *   (unless `merge` is true), then each source entry is recursed into.
+ * - **Arrays**: target is truncated or extended to match source length
+ *   (unless `merge` is true), then each element is recursed into.
+ * - **Primitives / type mismatch**: source is returned directly; the caller
+ *   is responsible for assigning the return value.
+ *
+ * @param target - The existing value to assign into.
+ * @param source - The new value to assign from.
+ * @param merge - When true, stale keys and excess array elements are preserved
+ *   rather than deleted. Defaults to false.
+ * @returns The mutated `target`, or `source` if types are incompatible.
+ */
+function deepAssign<T, V>(target: T, source: V, merge: boolean = false) {
+  if (Array.isArray(target) && Array.isArray(source)) {
+    while (!merge && target.length > source.length) target.pop();
+    // recurse and assign new values
+    for (const [index, item] of source.entries()) {
+      target[index] = deepAssign(target[index], item, merge);
+    }
+  } else if (
+    target &&
+    typeof target === "object" &&
+    source &&
+    typeof source === "object"
+  ) {
+    const record = target as Record<string, unknown>;
+
+    // clear stale keys
+    if (!merge)
+      for (const key of Object.keys(target)) {
+        if (!(key in source)) delete record[key];
+      }
+    // recurse and assign new values
+    for (const [key, item] of Object.entries(source)) {
+      record[key] = deepAssign(record[key], item, merge);
+    }
+  } else {
+    // new data doesn't match the types, so there is no referential equality to retain
+    return source;
+  }
+
+  return target;
+}
+
+type Index = string | number;
+
+/**
+ * Deep-sets a value at a key path on an object, preserving existing nested
+ * object and array references to maintain key insertion order.
+ *
+ * Intermediate objects are auto-vivified as needed. The final assignment is
+ * handled by {@link deepAssign}, which mutates the existing value in place
+ * rather than replacing it wholesale.
+ *
+ * @param obj - The root object to assign into.
+ * @param keys - Path of keys leading to the target location.
+ * @param value - The value to assign at the path.
+ * @param merge - When true, stale keys and excess array elements are preserved
+ *   rather than deleted. Defaults to false.
+ * @throws If `keys` is empty or contains an undefined key.
+ *
+ * @see {@link https://github.com/lukeed/dset} for the original dset implementation that inspired this API
+ */
+export function dsetAssign<V>(
+  obj: Record<Index, unknown>,
+  keys: Array<Index>,
+  value: V,
+  merge: boolean = false,
+): void {
+  const key = keys[keys.length - 1];
+  if (!key) throw Error("Unable to assign at path containing undefined keys");
+
+  // Walk the path, auto-vivifying intermediate objects when necessary
+  const target = keys
+    .slice(0, -1)
+    .reduce(
+      (acc, key) => (acc[key] ??= {}) as Record<string | number, unknown>,
+      obj,
+    );
+
+  // Deep assign the value into the target object for key
+  target[key] = deepAssign(target[key], value, merge);
+}

package/types/index.d.ts

@@ -0,0 +1,21 @@
+type Index = string | number;
+/**
+ * Deep-sets a value at a key path on an object, preserving existing nested
+ * object and array references to maintain key insertion order.
+ *
+ * Intermediate objects are auto-vivified as needed. The final assignment is
+ * handled by {@link deepAssign}, which mutates the existing value in place
+ * rather than replacing it wholesale.
+ *
+ * @param obj - The root object to assign into.
+ * @param keys - Path of keys leading to the target location.
+ * @param value - The value to assign at the path.
+ * @param merge - When true, stale keys and excess array elements are preserved
+ *   rather than deleted. Defaults to false.
+ * @throws If `keys` is empty or contains an undefined key.
+ *
+ * @see {@link https://github.com/lukeed/dset} for the original dset implementation that inspired this API
+ */
+export declare function dsetAssign<V>(obj: Record<Index, unknown>, keys: Array<Index>, value: V, merge?: boolean): void;
+export {};
+//# sourceMappingURL=index.d.ts.map