@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-BCEO3MGD.js

@@ -0,0 +1,244 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+
+// ../logix-core/src/internal/field-path.ts
+var isFieldPathSegment = (seg) => {
+  if (!seg) return false;
+  if (seg === "*") return false;
+  if (/^\d+$/.test(seg)) return false;
+  if (seg.includes("[") || seg.includes("]")) return false;
+  return true;
+};
+var normalizeFieldPath = (input) => {
+  if (typeof input === "string") {
+    const segs = splitSegments(input);
+    if (!segs || segs.length === 0) return void 0;
+    const normalized2 = segs.filter(isFieldPathSegment);
+    return normalized2.length > 0 ? normalized2 : void 0;
+  }
+  if (input.length === 0) return void 0;
+  let needsFilter = false;
+  for (const seg of input) {
+    if (!isFieldPathSegment(seg)) {
+      needsFilter = true;
+      break;
+    }
+  }
+  if (!needsFilter) return input;
+  const normalized = input.filter(isFieldPathSegment);
+  return normalized.length > 0 ? normalized : void 0;
+};
+var compareFieldPath = (a, b) => {
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const as = a[i];
+    const bs = b[i];
+    if (as === bs) continue;
+    return as < bs ? -1 : 1;
+  }
+  return a.length - b.length;
+};
+var isPrefixOf = (prefix, full) => {
+  if (prefix.length > full.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (prefix[i] !== full[i]) return false;
+  }
+  return true;
+};
+var canonicalizeRootsFast = (roots) => {
+  const sorted = Array.from(roots).sort(compareFieldPath);
+  const out = [];
+  for (const next of sorted) {
+    const prev = out[out.length - 1];
+    if (prev && isPrefixOf(prev, next)) continue;
+    out.push(next);
+  }
+  return out;
+};
+var makeFieldPathIdRegistry = (fieldPaths) => {
+  const root = { children: /* @__PURE__ */ new Map() };
+  const pathStringToId = /* @__PURE__ */ new Map();
+  const ambiguousPathStrings = /* @__PURE__ */ new Set();
+  for (let id = 0; id < fieldPaths.length; id++) {
+    const path = fieldPaths[id];
+    let node = root;
+    for (const seg of path) {
+      const children = node.children;
+      let next = children.get(seg);
+      if (!next) {
+        next = { children: /* @__PURE__ */ new Map() };
+        children.set(seg, next);
+      }
+      node = next;
+    }
+    node.id = id;
+    if (path.length > 0 && path.every((seg) => !seg.includes(".") && !seg.includes("[") && !seg.includes("]"))) {
+      const key = path.join(".");
+      if (ambiguousPathStrings.has(key)) continue;
+      if (pathStringToId.has(key)) {
+        ambiguousPathStrings.add(key);
+        pathStringToId.delete(key);
+        continue;
+      }
+      pathStringToId.set(key, id);
+    }
+  }
+  return { fieldPaths, root, pathStringToId };
+};
+var getFieldPathId = (registry, path) => {
+  let node = registry.root;
+  for (const seg of path) {
+    const next = node.children.get(seg);
+    if (!next) return void 0;
+    node = next;
+  }
+  return node.id;
+};
+var hashFieldPathIds = (ids) => {
+  let hash = 2166136261 >>> 0;
+  for (const id of ids) {
+    hash ^= id >>> 0;
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+};
+var dirtyPathsToDirtySet = (options) => {
+  if (options.dirtyAllReason) {
+    return { dirtyAll: true, reason: options.dirtyAllReason };
+  }
+  const canonical = canonicalizeRootsFast(options.dirtyPaths ?? []);
+  if (canonical.length === 0) {
+    return { dirtyAll: true, reason: options.sawStar ? "unknownWrite" : "unknownWrite" };
+  }
+  return { dirtyAll: false, paths: canonical };
+};
+var dirtyPathsToRootIds = (options) => {
+  let sawStar = false;
+  let hasInvalid = false;
+  let missing = false;
+  const ids = [];
+  for (const raw of options.dirtyPaths ?? []) {
+    if (raw === "*") {
+      sawStar = true;
+      continue;
+    }
+    if (typeof raw === "string") {
+      const direct = options.registry.pathStringToId?.get(raw);
+      if (direct != null) {
+        ids.push(direct);
+        continue;
+      }
+    }
+    const normalized = normalizeFieldPath(raw);
+    if (!normalized) {
+      hasInvalid = true;
+      continue;
+    }
+    const id = getFieldPathId(options.registry, normalized);
+    if (id == null) {
+      missing = true;
+      continue;
+    }
+    ids.push(id);
+  }
+  if (hasInvalid) {
+    return {
+      dirtyAll: true,
+      reason: "nonTrackablePatch",
+      rootIds: [],
+      rootCount: 0,
+      keySize: 0,
+      keyHash: 0
+    };
+  }
+  if (missing) {
+    return {
+      dirtyAll: true,
+      reason: "fallbackPolicy",
+      rootIds: [],
+      rootCount: 0,
+      keySize: 0,
+      keyHash: 0
+    };
+  }
+  const fieldPathsById = options.registry.fieldPaths;
+  ids.sort((a, b) => {
+    const ap = fieldPathsById[a];
+    const bp = fieldPathsById[b];
+    if (!ap || !bp) return a - b;
+    const cmp = compareFieldPath(ap, bp);
+    return cmp !== 0 ? cmp : a - b;
+  });
+  const rootIds = [];
+  let prev;
+  for (let i = 0; i < ids.length; i++) {
+    const id = ids[i];
+    const path = fieldPathsById[id];
+    if (!path) continue;
+    if (prev && isPrefixOf(prev, path)) continue;
+    rootIds.push(id);
+    prev = path;
+  }
+  const hasSpecific = rootIds.length > 0;
+  if (!hasSpecific && sawStar) {
+    return {
+      dirtyAll: true,
+      reason: "unknownWrite",
+      rootIds: [],
+      rootCount: 0,
+      keySize: 0,
+      keyHash: 0
+    };
+  }
+  rootIds.sort((a, b) => a - b);
+  const keyHash = hashFieldPathIds(rootIds);
+  return {
+    dirtyAll: false,
+    rootIds,
+    rootCount: rootIds.length,
+    keySize: rootIds.length,
+    keyHash
+  };
+};
+var splitSegments = (path) => {
+  if (!path) return void 0;
+  if (path === "*") return void 0;
+  const parts = path.split(".").filter((p) => p.length > 0);
+  const segs = [];
+  for (const part of parts) {
+    if (!part) continue;
+    if (part === "*") {
+      return void 0;
+    }
+    if (part.endsWith("[]")) {
+      const base = part.slice(0, -2);
+      if (base) segs.push(base);
+      continue;
+    }
+    const bracket = /^(.+)\[(\d+)\]$/.exec(part);
+    if (bracket) {
+      segs.push(bracket[1]);
+      continue;
+    }
+    if (/^\d+$/.test(part)) {
+      continue;
+    }
+    if (part.includes("[") || part.includes("]")) {
+      return void 0;
+    }
+    segs.push(part);
+  }
+  return segs;
+};
+
+export {
+  isFieldPathSegment,
+  normalizeFieldPath,
+  compareFieldPath,
+  isPrefixOf,
+  makeFieldPathIdRegistry,
+  getFieldPathId,
+  dirtyPathsToDirtySet,
+  dirtyPathsToRootIds
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/field-path.ts"],
  "sourcesContent": ["export type FieldPath = ReadonlyArray<string>\nexport type FieldPathId = number\n\nexport type DirtyAllReason = 'unknownWrite' | 'customMutation' | 'nonTrackablePatch' | 'fallbackPolicy'\n\nexport type DirtySet =\n  | {\n      readonly dirtyAll: true\n      readonly reason: DirtyAllReason\n    }\n  | {\n      readonly dirtyAll: false\n      readonly paths: ReadonlyArray<FieldPath>\n    }\n\ninterface FieldPathTrieNode {\n  id?: FieldPathId\n  children: Map<string, FieldPathTrieNode>\n}\n\nexport interface FieldPathIdRegistry {\n  readonly fieldPaths: ReadonlyArray<FieldPath>\n  readonly root: FieldPathTrieNode\n  /**\n   * Fast path: direct lookup for common string inputs (e.g. 'a.b').\n   *\n   * Note: This map is only safe for \"dot-separated\" paths. If a schema key itself contains '.',\n   * it is ambiguous with nested paths and should not rely on string-path APIs.\n   */\n  readonly pathStringToId?: ReadonlyMap<string, FieldPathId>\n}\n\nexport const isFieldPathSegment = (seg: string): boolean => {\n  if (!seg) return false\n  if (seg === '*') return false\n  if (/^\\d+$/.test(seg)) return false\n  if (seg.includes('[') || seg.includes(']')) return false\n  return true\n}\n\nexport const normalizeFieldPath = (input: string | FieldPath): FieldPath | undefined => {\n  if (typeof input === 'string') {\n    const segs = splitSegments(input)\n    if (!segs || segs.length === 0) return undefined\n    const normalized = segs.filter(isFieldPathSegment)\n    return normalized.length > 0 ? normalized : undefined\n  }\n\n  if (input.length === 0) return undefined\n\n  let needsFilter = false\n  for (const seg of input) {\n    if (!isFieldPathSegment(seg)) {\n      needsFilter = true\n      break\n    }\n  }\n\n  if (!needsFilter) return input\n\n  const normalized = input.filter(isFieldPathSegment)\n  return normalized.length > 0 ? normalized : undefined\n}\n\nexport const compareFieldPath = (a: FieldPath, b: FieldPath): number => {\n  const len = Math.min(a.length, b.length)\n  for (let i = 0; i < len; i++) {\n    const as = a[i]!\n    const bs = b[i]!\n    if (as === bs) continue\n    return as < bs ? -1 : 1\n  }\n  return a.length - b.length\n}\n\nexport const isPrefixOf = (prefix: FieldPath, full: FieldPath): boolean => {\n  if (prefix.length > full.length) return false\n  for (let i = 0; i < prefix.length; i++) {\n    if (prefix[i] !== full[i]) return false\n  }\n  return true\n}\n\nexport const toKey = (path: FieldPath): string => JSON.stringify(path)\n\nexport const toPathString = (path: FieldPath): string => path.join('.')\n\nexport const canonicalizeRoots = (roots: Iterable<FieldPath>): ReadonlyArray<FieldPath> => {\n  const byKey = new Map<string, FieldPath>()\n  for (const root of roots) {\n    const key = toKey(root)\n    if (!byKey.has(key)) byKey.set(key, root)\n  }\n\n  const sorted = Array.from(byKey.values()).sort(compareFieldPath)\n  const out: Array<FieldPath> = []\n  for (const next of sorted) {\n    const prev = out[out.length - 1]\n    if (prev && isPrefixOf(prev, next)) {\n      continue\n    }\n    out.push(next)\n  }\n  return out\n}\n\nexport const canonicalizeRootsFast = (roots: Iterable<FieldPath>): ReadonlyArray<FieldPath> => {\n  const sorted = Array.from(roots).sort(compareFieldPath)\n  const out: Array<FieldPath> = []\n  for (const next of sorted) {\n    const prev = out[out.length - 1]\n    if (prev && isPrefixOf(prev, next)) continue\n    out.push(next)\n  }\n  return out\n}\n\nexport const makeFieldPathIdRegistry = (fieldPaths: ReadonlyArray<FieldPath>): FieldPathIdRegistry => {\n  const root: FieldPathTrieNode = { children: new Map() }\n  const pathStringToId = new Map<string, FieldPathId>()\n  const ambiguousPathStrings = new Set<string>()\n\n  for (let id = 0; id < fieldPaths.length; id++) {\n    const path = fieldPaths[id]!\n    let node = root\n    for (const seg of path) {\n      const children = node.children\n      let next = children.get(seg)\n      if (!next) {\n        next = { children: new Map() }\n        children.set(seg, next)\n      }\n      node = next\n    }\n    node.id = id\n\n    if (path.length > 0 && path.every((seg) => !seg.includes('.') && !seg.includes('[') && !seg.includes(']'))) {\n      const key = path.join('.')\n      if (ambiguousPathStrings.has(key)) continue\n      if (pathStringToId.has(key)) {\n        ambiguousPathStrings.add(key)\n        pathStringToId.delete(key)\n        continue\n      }\n      pathStringToId.set(key, id)\n    }\n  }\n\n  return { fieldPaths, root, pathStringToId }\n}\n\nexport const getFieldPathId = (registry: FieldPathIdRegistry, path: FieldPath): FieldPathId | undefined => {\n  let node = registry.root\n  for (const seg of path) {\n    const next = node.children.get(seg)\n    if (!next) return undefined\n    node = next\n  }\n  return node.id\n}\n\nexport const getFieldPathIdFromString = (registry: FieldPathIdRegistry, path: string): FieldPathId | undefined => {\n  if (!path || path === '*') return undefined\n  const normalized = normalizeFieldPath(path)\n  if (!normalized) return undefined\n  return getFieldPathId(registry, normalized)\n}\n\nexport const hashFieldPathIds = (ids: ReadonlyArray<number>): number => {\n  // FNV-1a (32-bit)\n  let hash = 2166136261 >>> 0\n  for (const id of ids) {\n    hash ^= id >>> 0\n    hash = Math.imul(hash, 16777619)\n  }\n  return hash >>> 0\n}\n\nexport interface DirtyRootIds {\n  readonly dirtyAll: boolean\n  readonly reason?: DirtyAllReason\n  readonly rootIds: ReadonlyArray<FieldPathId>\n  readonly rootCount: number\n  readonly keySize: number\n  readonly keyHash: number\n}\n\nexport const dirtyPathsToDirtySet = (options: {\n  readonly dirtyPaths?: Iterable<FieldPath>\n  readonly sawStar?: boolean\n  readonly dirtyAllReason?: DirtyAllReason\n}): DirtySet => {\n  if (options.dirtyAllReason) {\n    return { dirtyAll: true, reason: options.dirtyAllReason }\n  }\n\n  const canonical = canonicalizeRootsFast(options.dirtyPaths ?? [])\n\n  if (canonical.length === 0) {\n    return { dirtyAll: true, reason: options.sawStar ? 'unknownWrite' : 'unknownWrite' }\n  }\n\n  return { dirtyAll: false, paths: canonical }\n}\n\nexport const dirtyPathsToRootIds = (options: {\n  readonly dirtyPaths?: Iterable<string | FieldPath>\n  readonly registry: FieldPathIdRegistry\n}): DirtyRootIds => {\n  let sawStar = false\n  let hasInvalid = false\n  let missing = false\n\n  const ids: Array<number> = []\n  for (const raw of options.dirtyPaths ?? []) {\n    if (raw === '*') {\n      sawStar = true\n      continue\n    }\n\n    if (typeof raw === 'string') {\n      const direct = options.registry.pathStringToId?.get(raw)\n      if (direct != null) {\n        ids.push(direct)\n        continue\n      }\n    }\n\n    const normalized = normalizeFieldPath(raw)\n    if (!normalized) {\n      hasInvalid = true\n      continue\n    }\n\n    const id = getFieldPathId(options.registry, normalized)\n    if (id == null) {\n      missing = true\n      continue\n    }\n    ids.push(id)\n  }\n\n  if (hasInvalid) {\n    return {\n      dirtyAll: true,\n      reason: 'nonTrackablePatch',\n      rootIds: [],\n      rootCount: 0,\n      keySize: 0,\n      keyHash: 0,\n    }\n  }\n\n  if (missing) {\n    return {\n      dirtyAll: true,\n      reason: 'fallbackPolicy',\n      rootIds: [],\n      rootCount: 0,\n      keySize: 0,\n      keyHash: 0,\n    }\n  }\n\n  const fieldPathsById = options.registry.fieldPaths\n  ids.sort((a, b) => {\n    const ap = fieldPathsById[a]\n    const bp = fieldPathsById[b]\n    if (!ap || !bp) return a - b\n    const cmp = compareFieldPath(ap, bp)\n    return cmp !== 0 ? cmp : a - b\n  })\n\n  const rootIds: Array<number> = []\n  let prev: FieldPath | undefined\n  for (let i = 0; i < ids.length; i++) {\n    const id = ids[i]!\n    const path = fieldPathsById[id]\n    if (!path) continue\n    if (prev && isPrefixOf(prev, path)) continue\n    rootIds.push(id)\n    prev = path\n  }\n\n  const hasSpecific = rootIds.length > 0\n\n  if (!hasSpecific && sawStar) {\n    return {\n      dirtyAll: true,\n      reason: 'unknownWrite',\n      rootIds: [],\n      rootCount: 0,\n      keySize: 0,\n      keyHash: 0,\n    }\n  }\n\n  rootIds.sort((a, b) => a - b)\n\n  const keyHash = hashFieldPathIds(rootIds)\n  return {\n    dirtyAll: false,\n    rootIds,\n    rootCount: rootIds.length,\n    keySize: rootIds.length,\n    keyHash,\n  }\n}\n\nconst splitSegments = (path: string): Array<string> | undefined => {\n  if (!path) return undefined\n  if (path === '*') return undefined\n\n  const parts = path.split('.').filter((p) => p.length > 0)\n  const segs: Array<string> = []\n\n  for (const part of parts) {\n    if (!part) continue\n    if (part === '*') {\n      return undefined\n    }\n    if (part.endsWith('[]')) {\n      const base = part.slice(0, -2)\n      if (base) segs.push(base)\n      continue\n    }\n    const bracket = /^(.+)\\[(\\d+)\\]$/.exec(part)\n    if (bracket) {\n      segs.push(bracket[1]!)\n      continue\n    }\n    if (/^\\d+$/.test(part)) {\n      continue\n    }\n    if (part.includes('[') || part.includes(']')) {\n      return undefined\n    }\n    segs.push(part)\n  }\n\n  return segs\n}\n"],
  "mappings": "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",
  "names": ["normalized"]
}
