@envive-ai/react-hooks 0.2.10-arthur-3 → 0.2.11

package/dist/application/utils/nodeSelector.cjs

@@ -0,0 +1,92 @@
+
+//#region src/application/utils/nodeSelector.ts
+var NodeSelector = class {
+	constructor(pattern) {
+		this.pattern = pattern;
+		this.root = document;
+	}
+	getPattern() {
+		return this.pattern;
+	}
+	setRoot(root) {
+		this.root = root;
+	}
+	getRoot() {
+		return this.root;
+	}
+};
+var QuerySelector = class extends NodeSelector {
+	parse() {
+		return this.getRoot().querySelector(this.getPattern());
+	}
+};
+var IDSelector = class extends NodeSelector {
+	parse() {
+		return this.getRoot().getElementById(this.getPattern());
+	}
+};
+var XpathSelector = class extends NodeSelector {
+	parse() {
+		return this.getRoot()?.evaluate(this.getPattern(), this.getRoot(), null, XPathResult.FIRST_ORDERED_NODE_TYPE, null)?.singleNodeValue;
+	}
+};
+var ChainSelector = class extends NodeSelector {
+	parse() {
+		let selectorIndex = 0;
+		const selectors = this.getPattern().split("@");
+		const lastIndex = selectors.length - 1;
+		const parseChain = (pattern, prevNode) => {
+			const selector = SelectorFactory.parse(pattern);
+			if (prevNode) selector.setRoot(prevNode);
+			const currentNode = selector.parse();
+			if (selectorIndex === lastIndex) return currentNode;
+			let node = currentNode || document;
+			if (currentNode?.shadowRoot) node = currentNode.shadowRoot;
+			if (currentNode?.contentWindow) node = currentNode.contentWindow?.document;
+			return parseChain(selectors[++selectorIndex].trim(), node);
+		};
+		return parseChain(selectors[selectorIndex].trim());
+	}
+};
+var Empty = class extends NodeSelector {
+	constructor() {
+		super("");
+	}
+	parse() {
+		return null;
+	}
+};
+var SelectorFactory = class {
+	static parse(composedSelector) {
+		if (!composedSelector) return new Empty();
+		const split = composedSelector.split("|");
+		const type = split[0];
+		const selector = split[1];
+		switch (type) {
+			case "id": return this.id(selector);
+			case "query": return this.query(selector);
+			case "xpath": return this.xpath(selector);
+			default: return new Empty();
+		}
+	}
+	static check(selector) {
+		return selector ?? new Empty();
+	}
+	static chain(pattern) {
+		return pattern ? new ChainSelector(pattern) : new Empty();
+	}
+	static id(pattern) {
+		return pattern ? new IDSelector(pattern) : new Empty();
+	}
+	static query(pattern) {
+		return pattern ? new QuerySelector(pattern) : new Empty();
+	}
+	static xpath(pattern) {
+		return pattern ? new XpathSelector(pattern) : new Empty();
+	}
+};
+
+//#endregion
+exports.NodeSelector = NodeSelector;
+exports.SelectorFactory = SelectorFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/utils/nodeSelector.d.cts

@@ -0,0 +1,28 @@
+//#region src/application/utils/nodeSelector.d.ts
+declare abstract class NodeSelector {
+  private pattern;
+  private root;
+  constructor(pattern: string);
+  getPattern(): string;
+  setRoot(root: Document): void;
+  getRoot(): Document;
+  abstract parse(): Node | null;
+}
+declare class ChainSelector extends NodeSelector {
+  parse(): Node | null;
+}
+declare class Empty extends NodeSelector {
+  constructor();
+  parse(): Node | null;
+}
+declare class SelectorFactory {
+  static parse(composedSelector?: string): NodeSelector;
+  static check(selector?: NodeSelector): NodeSelector;
+  static chain(pattern?: string): Empty | ChainSelector;
+  static id(pattern?: string): NodeSelector;
+  static query(pattern?: string): NodeSelector;
+  static xpath(pattern?: string): NodeSelector;
+}
+//#endregion
+export { NodeSelector, SelectorFactory };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZVNlbGVjdG9yLmQuY3RzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcHBsaWNhdGlvbi91dGlscy9ub2RlU2VsZWN0b3IuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVjbGFyZSBhYnN0cmFjdCBjbGFzcyBOb2RlU2VsZWN0b3Ige1xuICAgIHByaXZhdGUgcGF0dGVybjtcbiAgICBwcml2YXRlIHJvb3Q7XG4gICAgY29uc3RydWN0b3IocGF0dGVybjogc3RyaW5nKTtcbiAgICBnZXRQYXR0ZXJuKCk6IHN0cmluZztcbiAgICBzZXRSb290KHJvb3Q6IERvY3VtZW50KTogdm9pZDtcbiAgICBnZXRSb290KCk6IERvY3VtZW50O1xuICAgIGFic3RyYWN0IHBhcnNlKCk6IE5vZGUgfCBudWxsO1xufVxuZGVjbGFyZSBjbGFzcyBDaGFpblNlbGVjdG9yIGV4dGVuZHMgTm9kZVNlbGVjdG9yIHtcbiAgICBwYXJzZSgpOiBOb2RlIHwgbnVsbDtcbn1cbmRlY2xhcmUgY2xhc3MgRW1wdHkgZXh0ZW5kcyBOb2RlU2VsZWN0b3Ige1xuICAgIGNvbnN0cnVjdG9yKCk7XG4gICAgcGFyc2UoKTogTm9kZSB8IG51bGw7XG59XG5leHBvcnQgZGVjbGFyZSBjbGFzcyBTZWxlY3RvckZhY3Rvcnkge1xuICAgIHN0YXRpYyBwYXJzZShjb21wb3NlZFNlbGVjdG9yPzogc3RyaW5nKTogTm9kZVNlbGVjdG9yO1xuICAgIHN0YXRpYyBjaGVjayhzZWxlY3Rvcj86IE5vZGVTZWxlY3Rvcik6IE5vZGVTZWxlY3RvcjtcbiAgICBzdGF0aWMgY2hhaW4ocGF0dGVybj86IHN0cmluZyk6IEVtcHR5IHwgQ2hhaW5TZWxlY3RvcjtcbiAgICBzdGF0aWMgaWQocGF0dGVybj86IHN0cmluZyk6IE5vZGVTZWxlY3RvcjtcbiAgICBzdGF0aWMgcXVlcnkocGF0dGVybj86IHN0cmluZyk6IE5vZGVTZWxlY3RvcjtcbiAgICBzdGF0aWMgeHBhdGgocGF0dGVybj86IHN0cmluZyk6IE5vZGVTZWxlY3Rvcjtcbn1cbmV4cG9ydCB7fTtcbiJdLCJtYXBwaW5ncyI6IjtBQUFBLElBQVcsZUFBZTtDQUFDO09BQVc7T0FBSztPQUFBO0NBQUE7QUFDM0MsSUFBSSxnQkFBZTtDQUFBO09BQUE7T0FBQTtDQUFBO0FBQ25CLElBQUksUUFBUTtDQUFDO09BQUc7T0FBQTtDQUFBO0FBQ2hCLElBQVcsa0JBQWtCO0NBQUM7T0FBRTtPQUFBO09BQUE7T0FBQTtPQUFBO09BQUE7T0FBQTtPQUFBO0NBQUEifQ==

package/dist/application/utils/nodeSelector.d.ts

@@ -0,0 +1,28 @@
+//#region src/application/utils/nodeSelector.d.ts
+declare abstract class NodeSelector {
+  private pattern;
+  private root;
+  constructor(pattern: string);
+  getPattern(): string;
+  setRoot(root: Document): void;
+  getRoot(): Document;
+  abstract parse(): Node | null;
+}
+declare class ChainSelector extends NodeSelector {
+  parse(): Node | null;
+}
+declare class Empty extends NodeSelector {
+  constructor();
+  parse(): Node | null;
+}
+declare class SelectorFactory {
+  static parse(composedSelector?: string): NodeSelector;
+  static check(selector?: NodeSelector): NodeSelector;
+  static chain(pattern?: string): Empty | ChainSelector;
+  static id(pattern?: string): NodeSelector;
+  static query(pattern?: string): NodeSelector;
+  static xpath(pattern?: string): NodeSelector;
+}
+//#endregion
+export { NodeSelector, SelectorFactory };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZVNlbGVjdG9yLmQudHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL3V0aWxzL25vZGVTZWxlY3Rvci5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWNsYXJlIGFic3RyYWN0IGNsYXNzIE5vZGVTZWxlY3RvciB7XG4gICAgcHJpdmF0ZSBwYXR0ZXJuO1xuICAgIHByaXZhdGUgcm9vdDtcbiAgICBjb25zdHJ1Y3RvcihwYXR0ZXJuOiBzdHJpbmcpO1xuICAgIGdldFBhdHRlcm4oKTogc3RyaW5nO1xuICAgIHNldFJvb3Qocm9vdDogRG9jdW1lbnQpOiB2b2lkO1xuICAgIGdldFJvb3QoKTogRG9jdW1lbnQ7XG4gICAgYWJzdHJhY3QgcGFyc2UoKTogTm9kZSB8IG51bGw7XG59XG5kZWNsYXJlIGNsYXNzIENoYWluU2VsZWN0b3IgZXh0ZW5kcyBOb2RlU2VsZWN0b3Ige1xuICAgIHBhcnNlKCk6IE5vZGUgfCBudWxsO1xufVxuZGVjbGFyZSBjbGFzcyBFbXB0eSBleHRlbmRzIE5vZGVTZWxlY3RvciB7XG4gICAgY29uc3RydWN0b3IoKTtcbiAgICBwYXJzZSgpOiBOb2RlIHwgbnVsbDtcbn1cbmV4cG9ydCBkZWNsYXJlIGNsYXNzIFNlbGVjdG9yRmFjdG9yeSB7XG4gICAgc3RhdGljIHBhcnNlKGNvbXBvc2VkU2VsZWN0b3I/OiBzdHJpbmcpOiBOb2RlU2VsZWN0b3I7XG4gICAgc3RhdGljIGNoZWNrKHNlbGVjdG9yPzogTm9kZVNlbGVjdG9yKTogTm9kZVNlbGVjdG9yO1xuICAgIHN0YXRpYyBjaGFpbihwYXR0ZXJuPzogc3RyaW5nKTogRW1wdHkgfCBDaGFpblNlbGVjdG9yO1xuICAgIHN0YXRpYyBpZChwYXR0ZXJuPzogc3RyaW5nKTogTm9kZVNlbGVjdG9yO1xuICAgIHN0YXRpYyBxdWVyeShwYXR0ZXJuPzogc3RyaW5nKTogTm9kZVNlbGVjdG9yO1xuICAgIHN0YXRpYyB4cGF0aChwYXR0ZXJuPzogc3RyaW5nKTogTm9kZVNlbGVjdG9yO1xufVxuZXhwb3J0IHt9O1xuIl0sIm1hcHBpbmdzIjoiO0FBQUEsSUFBVyxlQUFlO0NBQUM7T0FBVztPQUFLO09BQUE7Q0FBQTtBQUMzQyxJQUFJLGdCQUFlO0NBQUE7T0FBQTtPQUFBO0NBQUE7QUFDbkIsSUFBSSxRQUFRO0NBQUM7T0FBRztPQUFBO0NBQUE7QUFDaEIsSUFBVyxrQkFBa0I7Q0FBQztPQUFFO09BQUE7T0FBQTtPQUFBO09BQUE7T0FBQTtPQUFBO09BQUE7Q0FBQSJ9

package/dist/application/utils/nodeSelector.js

@@ -0,0 +1,90 @@
+//#region src/application/utils/nodeSelector.ts
+var NodeSelector = class {
+	constructor(pattern) {
+		this.pattern = pattern;
+		this.root = document;
+	}
+	getPattern() {
+		return this.pattern;
+	}
+	setRoot(root) {
+		this.root = root;
+	}
+	getRoot() {
+		return this.root;
+	}
+};
+var QuerySelector = class extends NodeSelector {
+	parse() {
+		return this.getRoot().querySelector(this.getPattern());
+	}
+};
+var IDSelector = class extends NodeSelector {
+	parse() {
+		return this.getRoot().getElementById(this.getPattern());
+	}
+};
+var XpathSelector = class extends NodeSelector {
+	parse() {
+		return this.getRoot()?.evaluate(this.getPattern(), this.getRoot(), null, XPathResult.FIRST_ORDERED_NODE_TYPE, null)?.singleNodeValue;
+	}
+};
+var ChainSelector = class extends NodeSelector {
+	parse() {
+		let selectorIndex = 0;
+		const selectors = this.getPattern().split("@");
+		const lastIndex = selectors.length - 1;
+		const parseChain = (pattern, prevNode) => {
+			const selector = SelectorFactory.parse(pattern);
+			if (prevNode) selector.setRoot(prevNode);
+			const currentNode = selector.parse();
+			if (selectorIndex === lastIndex) return currentNode;
+			let node = currentNode || document;
+			if (currentNode?.shadowRoot) node = currentNode.shadowRoot;
+			if (currentNode?.contentWindow) node = currentNode.contentWindow?.document;
+			return parseChain(selectors[++selectorIndex].trim(), node);
+		};
+		return parseChain(selectors[selectorIndex].trim());
+	}
+};
+var Empty = class extends NodeSelector {
+	constructor() {
+		super("");
+	}
+	parse() {
+		return null;
+	}
+};
+var SelectorFactory = class {
+	static parse(composedSelector) {
+		if (!composedSelector) return new Empty();
+		const split = composedSelector.split("|");
+		const type = split[0];
+		const selector = split[1];
+		switch (type) {
+			case "id": return this.id(selector);
+			case "query": return this.query(selector);
+			case "xpath": return this.xpath(selector);
+			default: return new Empty();
+		}
+	}
+	static check(selector) {
+		return selector ?? new Empty();
+	}
+	static chain(pattern) {
+		return pattern ? new ChainSelector(pattern) : new Empty();
+	}
+	static id(pattern) {
+		return pattern ? new IDSelector(pattern) : new Empty();
+	}
+	static query(pattern) {
+		return pattern ? new QuerySelector(pattern) : new Empty();
+	}
+	static xpath(pattern) {
+		return pattern ? new XpathSelector(pattern) : new Empty();
+	}
+};
+
+//#endregion
+export { NodeSelector, SelectorFactory };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/utils/overrides.cjs

@@ -0,0 +1,95 @@
+
+//#region src/application/utils/overrides.ts
+function isPlainObject(x) {
+	return !!x && typeof x === "object" && !Array.isArray(x) && !(x instanceof Date) && !(x instanceof RegExp);
+}
+function isReplace(x) {
+	return !!x && typeof x === "object" && "$replace" in x;
+}
+function isDelete(x) {
+	return !!x && typeof x === "object" && x.$delete === true;
+}
+function isPrimitiveValue(x) {
+	const t = typeof x;
+	return x === null || t === "string" || t === "number" || t === "boolean" || t === "bigint" || t === "symbol" || t === "undefined";
+}
+function isArrayOfPrimitives(arr) {
+	if (arr.length === 0) return false;
+	for (let i = 0; i < arr.length; i += 1) {
+		const v = arr[i];
+		if (v !== void 0 && !isPrimitiveValue(v)) return false;
+	}
+	return true;
+}
+function mergeAny(baseAny, patchAny, opts) {
+	if (isReplace(patchAny)) return patchAny.$replace;
+	if (isDelete(patchAny)) return void 0;
+	if (Array.isArray(baseAny)) {
+		if (Array.isArray(patchAny)) {
+			const baseArr = baseAny;
+			const patchArr = patchAny;
+			if (opts.arrayStrategy === "replace" || isArrayOfPrimitives(baseArr) || isArrayOfPrimitives(patchArr)) return patchAny;
+			const out = baseArr.slice();
+			const max = Math.max(out.length, patchArr.length);
+			for (let i = 0; i < max; i += 1) {
+				const pVal = patchArr[i];
+				if (pVal !== void 0) out[i] = mergeAny(out[i], pVal, opts);
+			}
+			return out;
+		}
+		return baseAny;
+	}
+	if (isPlainObject(baseAny) && isPlainObject(patchAny)) {
+		const baseObj = baseAny;
+		const patchObj = patchAny;
+		const out = { ...baseObj };
+		for (const key of Object.keys(patchObj)) {
+			const pVal = patchObj[key];
+			if (pVal === void 0) {} else if (opts.nullDeletes && pVal === null) delete out[key];
+			else if (isReplace(pVal)) out[key] = pVal.$replace;
+			else if (isDelete(pVal)) delete out[key];
+			else out[key] = mergeAny(baseObj?.[key], pVal, opts);
+		}
+		return out;
+	}
+	return patchAny ?? baseAny;
+}
+function applyOverrides(base, patch, opts = {}) {
+	const { arrayStrategy = "mergeByIndex", nullDeletes = false } = opts;
+	if (isReplace(patch)) return patch.$replace;
+	if (isDelete(patch)) return void 0;
+	if (Array.isArray(base)) {
+		if (isReplace(patch)) return patch.$replace;
+		if (Array.isArray(patch)) {
+			if (arrayStrategy === "replace") return patch;
+			const out = base.slice();
+			const max = Math.max(out.length, patch.length);
+			for (let i = 0; i < max; i += 1) {
+				const pVal = patch[i];
+				if (pVal !== void 0) out[i] = mergeAny(out[i], pVal, opts);
+			}
+			return out;
+		}
+		return base;
+	}
+	if (isPlainObject(base) && isPlainObject(patch)) {
+		const out = { ...base };
+		const patchObj = patch;
+		for (const key of Object.keys(patchObj)) {
+			const pVal = patchObj[key];
+			if (pVal === void 0) {} else if (nullDeletes && pVal === null) delete out[key];
+			else if (isReplace(pVal)) out[key] = pVal.$replace;
+			else if (isDelete(pVal)) delete out[key];
+			else {
+				const bVal = base[key];
+				out[key] = mergeAny(bVal, pVal, opts);
+			}
+		}
+		return out;
+	}
+	return patch ?? base;
+}
+
+//#endregion
+exports.applyOverrides = applyOverrides;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"overrides.cjs","names":["out: Record<string, unknown>"],"sources":["../../../src/application/utils/overrides.ts"],"sourcesContent":["export type ReplaceOp<T> = { $replace: T };\nexport type DeleteOp = { $delete: true };\n\n// Treat these as atomic values (not recursed into)\ntype Builtin = Date | RegExp | ((...args: unknown[]) => unknown);\n\ntype Primitive = string | number | boolean | bigint | symbol | null | undefined;\n\n/**\n * Override<T> is a DeepPartial-like type with special operators:\n * - { $replace: T } to replace an entire subtree/array\n * - { $delete: true } to delete an object key\n *\n * Arrays behavior:\n * - Arrays of objects: merge-by-index by default (unless `arrayStrategy: 'replace'` or `$replace` is used)\n * - Arrays of primitives (string/number/boolean/...): replaced by default when a patch array is provided\n */\nexport type Override<T> =\n  // atomic\n  T extends Primitive | Builtin\n    ? T | ReplaceOp<T> | DeleteOp\n    : // arrays\n      T extends (infer U)[]\n      ? Array<Override<U> | undefined> | ReplaceOp<T>\n      : // maps/sets – keep simple: only allow full replace\n        T extends Map<unknown, unknown> | Set<unknown>\n        ? ReplaceOp<T>\n        : // objects\n          T extends object\n          ? { [K in keyof T]?: Override<T[K]> | DeleteOp | null } | ReplaceOp<T>\n          : T;\n\nexport type MergeOptions = {\n  /**\n   * How to treat arrays when patch provides an array (not $replace):\n   * - 'replace': always use patch array as whole value\n   * - 'mergeByIndex': merge each index recursively (default for arrays of objects)\n   * Note: Arrays of primitives are replaced by default regardless of this option.\n   */\n  arrayStrategy?: 'replace' | 'mergeByIndex';\n  /**\n   * If true, a `null` patch value deletes the key from an object (RFC 7396-ish)\n   */\n  nullDeletes?: boolean;\n};\n\n// Prevents T from being inferred from the 'patch' parameter; it must be inferred from 'base'.\n// See: https://github.com/microsoft/TypeScript/issues/14829#issuecomment-504042546\ntype NoInfer<T> = [T][T extends unknown ? 0 : never];\n\nfunction isPlainObject(x: unknown): x is Record<string, unknown> {\n  return (\n    !!x &&\n    typeof x === 'object' &&\n    !Array.isArray(x) &&\n    !(x instanceof Date) &&\n    !(x instanceof RegExp)\n  );\n}\n\nfunction isReplace(x: unknown): x is ReplaceOp<unknown> {\n  return !!x && typeof x === 'object' && '$replace' in (x as Record<string, unknown>);\n}\nfunction isDelete(x: unknown): x is DeleteOp {\n  return !!x && typeof x === 'object' && (x as Record<string, unknown>).$delete === true;\n}\n\nfunction isPrimitiveValue(x: unknown): boolean {\n  const t = typeof x;\n  return (\n    x === null ||\n    t === 'string' ||\n    t === 'number' ||\n    t === 'boolean' ||\n    t === 'bigint' ||\n    t === 'symbol' ||\n    t === 'undefined'\n  );\n}\n\nfunction isArrayOfPrimitives(arr: unknown[]): boolean {\n  if (arr.length === 0) return false; // ambiguous, default to merge-by-index on empty\n  // If every defined element is primitive, treat as primitives\n  for (let i = 0; i < arr.length; i += 1) {\n    const v = arr[i];\n    if (v !== undefined && !isPrimitiveValue(v)) return false;\n  }\n  return true;\n}\n\nfunction mergeAny(baseAny: unknown, patchAny: unknown, opts: MergeOptions): unknown {\n  if (isReplace(patchAny)) return patchAny.$replace as unknown;\n  if (isDelete(patchAny)) return undefined; // caller deletes the key\n\n  if (Array.isArray(baseAny)) {\n    if (Array.isArray(patchAny)) {\n      const baseArr = baseAny as unknown[];\n      const patchArr = patchAny as unknown[];\n      const shouldReplace =\n        opts.arrayStrategy === 'replace' ||\n        isArrayOfPrimitives(baseArr) ||\n        isArrayOfPrimitives(patchArr);\n      if (shouldReplace) return patchAny as unknown;\n      const out = baseArr.slice();\n      const max = Math.max(out.length, patchArr.length);\n      for (let i = 0; i < max; i += 1) {\n        const pVal = patchArr[i];\n        if (pVal !== undefined) {\n          out[i] = mergeAny(out[i], pVal, opts);\n        }\n      }\n      return out as unknown;\n    }\n    return baseAny as unknown;\n  }\n\n  if (isPlainObject(baseAny) && isPlainObject(patchAny)) {\n    const baseObj = baseAny as Record<string, unknown>;\n    const patchObj = patchAny as Record<string, unknown>;\n    const out: Record<string, unknown> = { ...baseObj };\n    for (const key of Object.keys(patchObj)) {\n      const pVal = patchObj[key];\n      if (pVal === undefined) {\n        // leave as-is\n      } else if (opts.nullDeletes && pVal === null) {\n        delete out[key];\n      } else if (isReplace(pVal)) {\n        out[key] = pVal.$replace;\n      } else if (isDelete(pVal)) {\n        delete out[key];\n      } else {\n        out[key] = mergeAny(baseObj?.[key], pVal, opts);\n      }\n    }\n    return out as unknown;\n  }\n\n  return (patchAny as unknown) ?? baseAny;\n}\n\nexport function applyOverrides<T>(\n  base: T,\n  patch: Override<NoInfer<T>>,\n  opts: MergeOptions = {},\n): T {\n  const { arrayStrategy = 'mergeByIndex', nullDeletes = false } = opts;\n\n  // Handle whole-node control operators on patch itself\n  if (isReplace(patch)) return patch.$replace as T;\n  if (isDelete(patch)) return undefined as unknown as T;\n\n  // Arrays\n  if (Array.isArray(base)) {\n    if (isReplace(patch)) return patch.$replace as T;\n    if (Array.isArray(patch)) {\n      if (arrayStrategy === 'replace') return patch as unknown as T;\n      // merge by index\n      const out = (base as unknown[]).slice();\n      const max = Math.max(out.length, patch.length);\n      for (let i = 0; i < max; i += 1) {\n        const pVal = (patch as unknown[])[i];\n        if (pVal !== undefined) {\n          out[i] = mergeAny(out[i], pVal, opts);\n        }\n      }\n      return out as unknown as T;\n    }\n    // invalid patch type for an array → ignore and return base\n    return base as T;\n  }\n\n  // Plain objects\n  if (isPlainObject(base) && isPlainObject(patch)) {\n    const out: Record<string, unknown> = { ...(base as Record<string, unknown>) };\n    const patchObj = patch as Record<string, unknown>;\n    for (const key of Object.keys(patchObj)) {\n      const pVal = patchObj[key];\n      if (pVal === undefined) {\n        // leave existing value\n      } else if (nullDeletes && pVal === null) {\n        delete out[key];\n      } else if (isReplace(pVal)) {\n        out[key] = pVal.$replace;\n      } else if (isDelete(pVal)) {\n        delete out[key];\n      } else {\n        const bVal = (base as Record<string, unknown>)[key];\n        out[key] = mergeAny(bVal, pVal, opts);\n      }\n    }\n    return out as unknown as T;\n  }\n\n  // For primitives or when patch is primitive, patch wins if defined\n  return ((patch as unknown) ?? base) as T;\n}\n"],"mappings":"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"}

package/dist/application/utils/overrides.d.cts

@@ -0,0 +1,37 @@
+//#region src/application/utils/overrides.d.ts
+type ReplaceOp<T> = {
+  $replace: T;
+};
+type DeleteOp = {
+  $delete: true;
+};
+type Builtin = Date | RegExp | ((...args: unknown[]) => unknown);
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+/**
+ * Override<T> is a DeepPartial-like type with special operators:
+ * - { $replace: T } to replace an entire subtree/array
+ * - { $delete: true } to delete an object key
+ *
+ * Arrays behavior:
+ * - Arrays of objects: merge-by-index by default (unless `arrayStrategy: 'replace'` or `$replace` is used)
+ * - Arrays of primitives (string/number/boolean/...): replaced by default when a patch array is provided
+ */
+type Override<T> = T extends Primitive | Builtin ? T | ReplaceOp<T> | DeleteOp : T extends (infer U)[] ? Array<Override<U> | undefined> | ReplaceOp<T> : T extends Map<unknown, unknown> | Set<unknown> ? ReplaceOp<T> : T extends object ? { [K in keyof T]?: Override<T[K]> | DeleteOp | null } | ReplaceOp<T> : T;
+type MergeOptions = {
+  /**
+   * How to treat arrays when patch provides an array (not $replace):
+   * - 'replace': always use patch array as whole value
+   * - 'mergeByIndex': merge each index recursively (default for arrays of objects)
+   * Note: Arrays of primitives are replaced by default regardless of this option.
+   */
+  arrayStrategy?: 'replace' | 'mergeByIndex';
+  /**
+   * If true, a `null` patch value deletes the key from an object (RFC 7396-ish)
+   */
+  nullDeletes?: boolean;
+};
+type NoInfer<T> = [T][T extends unknown ? 0 : never];
+declare function applyOverrides<T>(base: T, patch: Override<NoInfer<T>>, opts?: MergeOptions): T;
+//#endregion
+export { DeleteOp, MergeOptions, Override, ReplaceOp, applyOverrides };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/utils/overrides.d.ts

@@ -0,0 +1,37 @@
+//#region src/application/utils/overrides.d.ts
+type ReplaceOp<T> = {
+  $replace: T;
+};
+type DeleteOp = {
+  $delete: true;
+};
+type Builtin = Date | RegExp | ((...args: unknown[]) => unknown);
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+/**
+ * Override<T> is a DeepPartial-like type with special operators:
+ * - { $replace: T } to replace an entire subtree/array
+ * - { $delete: true } to delete an object key
+ *
+ * Arrays behavior:
+ * - Arrays of objects: merge-by-index by default (unless `arrayStrategy: 'replace'` or `$replace` is used)
+ * - Arrays of primitives (string/number/boolean/...): replaced by default when a patch array is provided
+ */
+type Override<T> = T extends Primitive | Builtin ? T | ReplaceOp<T> | DeleteOp : T extends (infer U)[] ? Array<Override<U> | undefined> | ReplaceOp<T> : T extends Map<unknown, unknown> | Set<unknown> ? ReplaceOp<T> : T extends object ? { [K in keyof T]?: Override<T[K]> | DeleteOp | null } | ReplaceOp<T> : T;
+type MergeOptions = {
+  /**
+   * How to treat arrays when patch provides an array (not $replace):
+   * - 'replace': always use patch array as whole value
+   * - 'mergeByIndex': merge each index recursively (default for arrays of objects)
+   * Note: Arrays of primitives are replaced by default regardless of this option.
+   */
+  arrayStrategy?: 'replace' | 'mergeByIndex';
+  /**
+   * If true, a `null` patch value deletes the key from an object (RFC 7396-ish)
+   */
+  nullDeletes?: boolean;
+};
+type NoInfer<T> = [T][T extends unknown ? 0 : never];
+declare function applyOverrides<T>(base: T, patch: Override<NoInfer<T>>, opts?: MergeOptions): T;
+//#endregion
+export { DeleteOp, MergeOptions, Override, ReplaceOp, applyOverrides };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/utils/overrides.js

@@ -0,0 +1,94 @@
+//#region src/application/utils/overrides.ts
+function isPlainObject(x) {
+	return !!x && typeof x === "object" && !Array.isArray(x) && !(x instanceof Date) && !(x instanceof RegExp);
+}
+function isReplace(x) {
+	return !!x && typeof x === "object" && "$replace" in x;
+}
+function isDelete(x) {
+	return !!x && typeof x === "object" && x.$delete === true;
+}
+function isPrimitiveValue(x) {
+	const t = typeof x;
+	return x === null || t === "string" || t === "number" || t === "boolean" || t === "bigint" || t === "symbol" || t === "undefined";
+}
+function isArrayOfPrimitives(arr) {
+	if (arr.length === 0) return false;
+	for (let i = 0; i < arr.length; i += 1) {
+		const v = arr[i];
+		if (v !== void 0 && !isPrimitiveValue(v)) return false;
+	}
+	return true;
+}
+function mergeAny(baseAny, patchAny, opts) {
+	if (isReplace(patchAny)) return patchAny.$replace;
+	if (isDelete(patchAny)) return void 0;
+	if (Array.isArray(baseAny)) {
+		if (Array.isArray(patchAny)) {
+			const baseArr = baseAny;
+			const patchArr = patchAny;
+			if (opts.arrayStrategy === "replace" || isArrayOfPrimitives(baseArr) || isArrayOfPrimitives(patchArr)) return patchAny;
+			const out = baseArr.slice();
+			const max = Math.max(out.length, patchArr.length);
+			for (let i = 0; i < max; i += 1) {
+				const pVal = patchArr[i];
+				if (pVal !== void 0) out[i] = mergeAny(out[i], pVal, opts);
+			}
+			return out;
+		}
+		return baseAny;
+	}
+	if (isPlainObject(baseAny) && isPlainObject(patchAny)) {
+		const baseObj = baseAny;
+		const patchObj = patchAny;
+		const out = { ...baseObj };
+		for (const key of Object.keys(patchObj)) {
+			const pVal = patchObj[key];
+			if (pVal === void 0) {} else if (opts.nullDeletes && pVal === null) delete out[key];
+			else if (isReplace(pVal)) out[key] = pVal.$replace;
+			else if (isDelete(pVal)) delete out[key];
+			else out[key] = mergeAny(baseObj?.[key], pVal, opts);
+		}
+		return out;
+	}
+	return patchAny ?? baseAny;
+}
+function applyOverrides(base, patch, opts = {}) {
+	const { arrayStrategy = "mergeByIndex", nullDeletes = false } = opts;
+	if (isReplace(patch)) return patch.$replace;
+	if (isDelete(patch)) return void 0;
+	if (Array.isArray(base)) {
+		if (isReplace(patch)) return patch.$replace;
+		if (Array.isArray(patch)) {
+			if (arrayStrategy === "replace") return patch;
+			const out = base.slice();
+			const max = Math.max(out.length, patch.length);
+			for (let i = 0; i < max; i += 1) {
+				const pVal = patch[i];
+				if (pVal !== void 0) out[i] = mergeAny(out[i], pVal, opts);
+			}
+			return out;
+		}
+		return base;
+	}
+	if (isPlainObject(base) && isPlainObject(patch)) {
+		const out = { ...base };
+		const patchObj = patch;
+		for (const key of Object.keys(patchObj)) {
+			const pVal = patchObj[key];
+			if (pVal === void 0) {} else if (nullDeletes && pVal === null) delete out[key];
+			else if (isReplace(pVal)) out[key] = pVal.$replace;
+			else if (isDelete(pVal)) delete out[key];
+			else {
+				const bVal = base[key];
+				out[key] = mergeAny(bVal, pVal, opts);
+			}
+		}
+		return out;
+	}
+	return patch ?? base;
+}
+
+//#endregion
+export { applyOverrides };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"overrides.js","names":["out: Record<string, unknown>"],"sources":["../../../src/application/utils/overrides.ts"],"sourcesContent":["export type ReplaceOp<T> = { $replace: T };\nexport type DeleteOp = { $delete: true };\n\n// Treat these as atomic values (not recursed into)\ntype Builtin = Date | RegExp | ((...args: unknown[]) => unknown);\n\ntype Primitive = string | number | boolean | bigint | symbol | null | undefined;\n\n/**\n * Override<T> is a DeepPartial-like type with special operators:\n * - { $replace: T } to replace an entire subtree/array\n * - { $delete: true } to delete an object key\n *\n * Arrays behavior:\n * - Arrays of objects: merge-by-index by default (unless `arrayStrategy: 'replace'` or `$replace` is used)\n * - Arrays of primitives (string/number/boolean/...): replaced by default when a patch array is provided\n */\nexport type Override<T> =\n  // atomic\n  T extends Primitive | Builtin\n    ? T | ReplaceOp<T> | DeleteOp\n    : // arrays\n      T extends (infer U)[]\n      ? Array<Override<U> | undefined> | ReplaceOp<T>\n      : // maps/sets – keep simple: only allow full replace\n        T extends Map<unknown, unknown> | Set<unknown>\n        ? ReplaceOp<T>\n        : // objects\n          T extends object\n          ? { [K in keyof T]?: Override<T[K]> | DeleteOp | null } | ReplaceOp<T>\n          : T;\n\nexport type MergeOptions = {\n  /**\n   * How to treat arrays when patch provides an array (not $replace):\n   * - 'replace': always use patch array as whole value\n   * - 'mergeByIndex': merge each index recursively (default for arrays of objects)\n   * Note: Arrays of primitives are replaced by default regardless of this option.\n   */\n  arrayStrategy?: 'replace' | 'mergeByIndex';\n  /**\n   * If true, a `null` patch value deletes the key from an object (RFC 7396-ish)\n   */\n  nullDeletes?: boolean;\n};\n\n// Prevents T from being inferred from the 'patch' parameter; it must be inferred from 'base'.\n// See: https://github.com/microsoft/TypeScript/issues/14829#issuecomment-504042546\ntype NoInfer<T> = [T][T extends unknown ? 0 : never];\n\nfunction isPlainObject(x: unknown): x is Record<string, unknown> {\n  return (\n    !!x &&\n    typeof x === 'object' &&\n    !Array.isArray(x) &&\n    !(x instanceof Date) &&\n    !(x instanceof RegExp)\n  );\n}\n\nfunction isReplace(x: unknown): x is ReplaceOp<unknown> {\n  return !!x && typeof x === 'object' && '$replace' in (x as Record<string, unknown>);\n}\nfunction isDelete(x: unknown): x is DeleteOp {\n  return !!x && typeof x === 'object' && (x as Record<string, unknown>).$delete === true;\n}\n\nfunction isPrimitiveValue(x: unknown): boolean {\n  const t = typeof x;\n  return (\n    x === null ||\n    t === 'string' ||\n    t === 'number' ||\n    t === 'boolean' ||\n    t === 'bigint' ||\n    t === 'symbol' ||\n    t === 'undefined'\n  );\n}\n\nfunction isArrayOfPrimitives(arr: unknown[]): boolean {\n  if (arr.length === 0) return false; // ambiguous, default to merge-by-index on empty\n  // If every defined element is primitive, treat as primitives\n  for (let i = 0; i < arr.length; i += 1) {\n    const v = arr[i];\n    if (v !== undefined && !isPrimitiveValue(v)) return false;\n  }\n  return true;\n}\n\nfunction mergeAny(baseAny: unknown, patchAny: unknown, opts: MergeOptions): unknown {\n  if (isReplace(patchAny)) return patchAny.$replace as unknown;\n  if (isDelete(patchAny)) return undefined; // caller deletes the key\n\n  if (Array.isArray(baseAny)) {\n    if (Array.isArray(patchAny)) {\n      const baseArr = baseAny as unknown[];\n      const patchArr = patchAny as unknown[];\n      const shouldReplace =\n        opts.arrayStrategy === 'replace' ||\n        isArrayOfPrimitives(baseArr) ||\n        isArrayOfPrimitives(patchArr);\n      if (shouldReplace) return patchAny as unknown;\n      const out = baseArr.slice();\n      const max = Math.max(out.length, patchArr.length);\n      for (let i = 0; i < max; i += 1) {\n        const pVal = patchArr[i];\n        if (pVal !== undefined) {\n          out[i] = mergeAny(out[i], pVal, opts);\n        }\n      }\n      return out as unknown;\n    }\n    return baseAny as unknown;\n  }\n\n  if (isPlainObject(baseAny) && isPlainObject(patchAny)) {\n    const baseObj = baseAny as Record<string, unknown>;\n    const patchObj = patchAny as Record<string, unknown>;\n    const out: Record<string, unknown> = { ...baseObj };\n    for (const key of Object.keys(patchObj)) {\n      const pVal = patchObj[key];\n      if (pVal === undefined) {\n        // leave as-is\n      } else if (opts.nullDeletes && pVal === null) {\n        delete out[key];\n      } else if (isReplace(pVal)) {\n        out[key] = pVal.$replace;\n      } else if (isDelete(pVal)) {\n        delete out[key];\n      } else {\n        out[key] = mergeAny(baseObj?.[key], pVal, opts);\n      }\n    }\n    return out as unknown;\n  }\n\n  return (patchAny as unknown) ?? baseAny;\n}\n\nexport function applyOverrides<T>(\n  base: T,\n  patch: Override<NoInfer<T>>,\n  opts: MergeOptions = {},\n): T {\n  const { arrayStrategy = 'mergeByIndex', nullDeletes = false } = opts;\n\n  // Handle whole-node control operators on patch itself\n  if (isReplace(patch)) return patch.$replace as T;\n  if (isDelete(patch)) return undefined as unknown as T;\n\n  // Arrays\n  if (Array.isArray(base)) {\n    if (isReplace(patch)) return patch.$replace as T;\n    if (Array.isArray(patch)) {\n      if (arrayStrategy === 'replace') return patch as unknown as T;\n      // merge by index\n      const out = (base as unknown[]).slice();\n      const max = Math.max(out.length, patch.length);\n      for (let i = 0; i < max; i += 1) {\n        const pVal = (patch as unknown[])[i];\n        if (pVal !== undefined) {\n          out[i] = mergeAny(out[i], pVal, opts);\n        }\n      }\n      return out as unknown as T;\n    }\n    // invalid patch type for an array → ignore and return base\n    return base as T;\n  }\n\n  // Plain objects\n  if (isPlainObject(base) && isPlainObject(patch)) {\n    const out: Record<string, unknown> = { ...(base as Record<string, unknown>) };\n    const patchObj = patch as Record<string, unknown>;\n    for (const key of Object.keys(patchObj)) {\n      const pVal = patchObj[key];\n      if (pVal === undefined) {\n        // leave existing value\n      } else if (nullDeletes && pVal === null) {\n        delete out[key];\n      } else if (isReplace(pVal)) {\n        out[key] = pVal.$replace;\n      } else if (isDelete(pVal)) {\n        delete out[key];\n      } else {\n        const bVal = (base as Record<string, unknown>)[key];\n        out[key] = mergeAny(bVal, pVal, opts);\n      }\n    }\n    return out as unknown as T;\n  }\n\n  // For primitives or when patch is primitive, patch wins if defined\n  return ((patch as unknown) ?? base) as T;\n}\n"],"mappings":"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"}

package/dist/application/utils/stringUtils.cjs

@@ -0,0 +1,35 @@
+
+//#region src/application/utils/stringUtils.ts
+var StringUtils = class StringUtils {
+	static isNullOrEmpty(value) {
+		const valueTrimmed = value?.trim();
+		return value === void 0 || valueTrimmed === "";
+	}
+	static trimToNull(value) {
+		const valueTrimmed = value?.trim();
+		return StringUtils.isNullOrEmpty(valueTrimmed) ? void 0 : valueTrimmed;
+	}
+	static capitalize(type) {
+		if (type === void 0) return "";
+		return type.charAt(0).toUpperCase() + type.substring(1);
+	}
+	/**
+	* Finds the first pattern in an array that matches a given URL.
+	* Patterns can include a single wildcard '*' which matches any sequence of characters.
+	*
+	* @param patterns
+	* @param urlToTest
+	* @returns
+	*/
+	static findMatchingPattern(patterns, urlToTest) {
+		if (!urlToTest) return;
+		for (const pattern of patterns) if (urlToTest.pathname !== "/") {
+			const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+			if ((/* @__PURE__ */ new RegExp(`^${regexPattern}$`)).test(urlToTest.pathname)) return pattern;
+		} else if (pattern.startsWith(urlToTest.hostname)) return pattern;
+	}
+};
+
+//#endregion
+exports.StringUtils = StringUtils;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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