@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,245 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+
+// ../logix-core/src/internal/state-trait/meta.ts
+var uniqSortedStrings = (input) => {
+  const set = /* @__PURE__ */ new Set();
+  for (const item of input) {
+    const v = item.trim();
+    if (!v) continue;
+    set.add(v);
+  }
+  return Array.from(set).sort();
+};
+var isPlainRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var sanitizeJsonValue = (input, depth, stats) => {
+  if (input === null) return null;
+  if (typeof input === "string") return input;
+  if (typeof input === "boolean") return input;
+  if (typeof input === "number") {
+    if (!Number.isFinite(input)) {
+      stats.dropped += 1;
+      stats.nonSerializable += 1;
+      stats.nonFiniteNumber += 1;
+      return void 0;
+    }
+    return input;
+  }
+  if (depth >= 6) {
+    stats.dropped += 1;
+    stats.depthExceeded += 1;
+    return void 0;
+  }
+  if (Array.isArray(input)) {
+    const out = [];
+    for (const item of input) {
+      const v = sanitizeJsonValue(item, depth + 1, stats);
+      if (v !== void 0) out.push(v);
+    }
+    return out;
+  }
+  if (isPlainRecord(input)) {
+    const keys = Object.keys(input).sort();
+    const out = {};
+    for (const key of keys) {
+      const v = sanitizeJsonValue(input[key], depth + 1, stats);
+      if (v !== void 0) out[key] = v;
+    }
+    return out;
+  }
+  stats.dropped += 1;
+  stats.nonSerializable += 1;
+  return void 0;
+};
+var pushSample = (target, value, limit) => {
+  if (target.length >= limit) return;
+  target.push(value);
+};
+var sanitizeWithReport = (input) => {
+  if (input === null || input === void 0) return {};
+  if (typeof input !== "object" || Array.isArray(input)) {
+    return { report: { invalidInput: true } };
+  }
+  const record = input;
+  const out = {};
+  const reportUnknownKeys = [];
+  let unknownKeyCount = 0;
+  const reportDroppedKeys = [];
+  let droppedTagItems = 0;
+  const reportIgnoredAnnotationKeys = [];
+  let ignoredAnnotationKeyCount = 0;
+  const reportDroppedAnnotationKeys = [];
+  let droppedAnnotationKeyCount = 0;
+  const stats = { dropped: 0, nonSerializable: 0, depthExceeded: 0, nonFiniteNumber: 0 };
+  const allowed = /* @__PURE__ */ new Set([
+    "label",
+    "description",
+    "group",
+    "docsUrl",
+    "cacheGroup",
+    "canonical",
+    "tags",
+    "annotations"
+  ]);
+  for (const key of Object.keys(record)) {
+    if (allowed.has(key) || key.startsWith("x-")) continue;
+    unknownKeyCount += 1;
+    pushSample(reportUnknownKeys, key, 8);
+  }
+  const pickString = (key) => {
+    const value = record[key];
+    if (typeof value !== "string") return;
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    out[key] = trimmed;
+  };
+  pickString("label");
+  pickString("description");
+  pickString("group");
+  pickString("docsUrl");
+  pickString("cacheGroup");
+  const canonical = record.canonical;
+  if (canonical !== void 0 && canonical !== null && typeof canonical !== "boolean") {
+    pushSample(reportDroppedKeys, "canonical", 8);
+  } else if (typeof canonical === "boolean") {
+    out.canonical = canonical;
+  }
+  const tagsRaw = record.tags;
+  if (typeof tagsRaw === "string") {
+    const tags = uniqSortedStrings([tagsRaw]);
+    if (tags.length > 0) out.tags = tags;
+  } else if (Array.isArray(tagsRaw)) {
+    const raw = tagsRaw.filter((x) => typeof x === "string");
+    droppedTagItems += tagsRaw.length - raw.length;
+    const tags = uniqSortedStrings(raw);
+    if (tags.length > 0) out.tags = tags;
+    droppedTagItems += raw.length - tags.length;
+  } else if (tagsRaw !== void 0 && tagsRaw !== null) {
+    pushSample(reportDroppedKeys, "tags", 8);
+  }
+  const annotations = {};
+  const annotationKeys = Object.keys(record).filter((k) => k.startsWith("x-")).sort();
+  for (const key of annotationKeys) {
+    const v = sanitizeJsonValue(record[key], 0, stats);
+    if (v !== void 0) {
+      annotations[key] = v;
+    } else {
+      droppedAnnotationKeyCount += 1;
+      pushSample(reportDroppedAnnotationKeys, key, 8);
+    }
+  }
+  const annotationsRaw = record.annotations;
+  if (annotationsRaw !== void 0 && annotationsRaw !== null && !isPlainRecord(annotationsRaw)) {
+    pushSample(reportDroppedKeys, "annotations", 8);
+  } else if (isPlainRecord(annotationsRaw)) {
+    const keys = Object.keys(annotationsRaw).sort();
+    for (const key of keys) {
+      if (!key.startsWith("x-")) {
+        ignoredAnnotationKeyCount += 1;
+        pushSample(reportIgnoredAnnotationKeys, key, 8);
+        continue;
+      }
+      const v = sanitizeJsonValue(annotationsRaw[key], 0, stats);
+      if (v !== void 0) {
+        annotations[key] = v;
+      } else {
+        droppedAnnotationKeyCount += 1;
+        pushSample(reportDroppedAnnotationKeys, key, 8);
+      }
+    }
+  }
+  if (Object.keys(annotations).length > 0) out.annotations = annotations;
+  for (const key of ["label", "description", "group", "docsUrl", "cacheGroup"]) {
+    const value = record[key];
+    if (value !== void 0 && value !== null && typeof value !== "string") {
+      pushSample(reportDroppedKeys, key, 8);
+    }
+  }
+  const meta = Object.keys(out).length > 0 ? out : void 0;
+  const report = (() => {
+    const hasUnknownKeys = unknownKeyCount > 0;
+    const hasDroppedKeys = reportDroppedKeys.length > 0;
+    const hasDroppedTagItems = droppedTagItems > 0;
+    const hasIgnoredAnnotationKeys = ignoredAnnotationKeyCount > 0;
+    const hasDroppedAnnotations = droppedAnnotationKeyCount > 0 || stats.dropped > 0;
+    if (!hasUnknownKeys && !hasDroppedKeys && !hasDroppedTagItems && !hasIgnoredAnnotationKeys && !hasDroppedAnnotations) {
+      return void 0;
+    }
+    return {
+      ...hasUnknownKeys ? { unknownKeys: reportUnknownKeys, unknownKeyCount } : {},
+      ...hasDroppedKeys ? { droppedKeys: uniqSortedStrings(reportDroppedKeys) } : {},
+      ...hasDroppedTagItems ? { droppedTagItems } : {},
+      ...hasIgnoredAnnotationKeys ? { ignoredAnnotationKeys: uniqSortedStrings(reportIgnoredAnnotationKeys), ignoredAnnotationKeyCount } : {},
+      ...hasDroppedAnnotations ? {
+        droppedAnnotationKeys: uniqSortedStrings(reportDroppedAnnotationKeys),
+        droppedAnnotationKeyCount,
+        droppedAnnotationValues: stats.dropped,
+        droppedAnnotationNonSerializable: stats.nonSerializable,
+        droppedAnnotationDepthExceeded: stats.depthExceeded,
+        droppedAnnotationNonFiniteNumber: stats.nonFiniteNumber
+      } : {}
+    };
+  })();
+  return report ? { meta, report } : { meta };
+};
+var sanitize = (input) => sanitizeWithReport(input).meta;
+var stableStringify = (meta) => {
+  const out = {};
+  const keys = Object.keys(meta).sort();
+  for (const k of keys) {
+    out[k] = meta[k];
+  }
+  return JSON.stringify(out);
+};
+var equals = (a, b) => {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return stableStringify(a) === stableStringify(b);
+};
+var mergeCanonical = (current, incoming) => {
+  const existing = current.meta;
+  if (!existing) {
+    return {
+      meta: incoming.meta,
+      origin: incoming.origin,
+      conflicts: current.conflicts
+    };
+  }
+  if (equals(existing, incoming.meta)) {
+    return current;
+  }
+  const conflicts = [...current.conflicts ?? []];
+  const push = (conflict) => {
+    const exists = conflicts.some((c) => c.origin === conflict.origin && equals(c.meta, conflict.meta));
+    if (!exists) conflicts.push(conflict);
+  };
+  const existingCanonical = existing.canonical === true;
+  const incomingCanonical = incoming.meta.canonical === true;
+  if (!existingCanonical && incomingCanonical) {
+    push({
+      origin: current.origin ?? "unknown",
+      meta: existing
+    });
+    return {
+      meta: incoming.meta,
+      origin: incoming.origin,
+      conflicts
+    };
+  }
+  push({
+    origin: incoming.origin,
+    meta: incoming.meta
+  });
+  return {
+    meta: existing,
+    origin: current.origin ?? incoming.origin,
+    conflicts
+  };
+};
+
+export {
+  sanitizeWithReport,
+  sanitize,
+  mergeCanonical
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/state-trait/meta.ts"],
  "sourcesContent": ["import type { JsonValue } from '../observability/jsonValue.js'\n\nexport type TraitMeta = Readonly<{\n  readonly label?: string\n  readonly description?: string\n  readonly tags?: ReadonlyArray<string>\n  readonly group?: string\n  readonly docsUrl?: string\n  readonly cacheGroup?: string\n  /**\n   * Extension annotations: only accepts `x-*` keys (anchors for capabilities like Phantom Source / Drift Detection).\n   *\n   * Constraints:\n   * - Must be serializable (JSON values).\n   * - Must be slim (keep only a few key hints; don't stuff large objects).\n   */\n  readonly annotations?: Readonly<Record<string, JsonValue>>\n  /**\n   * Semantic hint: when the same entity (e.g. the same resourceId) has multiple inconsistent meta declarations,\n   * the one with canonical=true becomes the \"display canonical\", and others are recorded as conflicts.\n   */\n  readonly canonical?: boolean\n}>\n\nexport type TraitMetaSanitizeReport = Readonly<{\n  /**\n   * invalidInput:\n   * - Input was not a plain object (e.g. string/array/function/etc).\n   */\n  readonly invalidInput?: boolean\n  /**\n   * unknownKeys:\n   * - Top-level keys that are ignored (not part of TraitMeta, and not `x-*` legacy annotations).\n   */\n  readonly unknownKeys?: ReadonlyArray<string>\n  readonly unknownKeyCount?: number\n  /**\n   * droppedKeys:\n   * - Known keys that exist but are dropped due to invalid value type (e.g. tags is not string/array).\n   */\n  readonly droppedKeys?: ReadonlyArray<string>\n  /**\n   * droppedTagItems:\n   * - Number of non-string/empty tag items dropped during normalization.\n   */\n  readonly droppedTagItems?: number\n  /**\n   * annotations:\n   * - Only accepts `x-*` keys; invalid keys/values are dropped.\n   */\n  readonly ignoredAnnotationKeys?: ReadonlyArray<string>\n  readonly ignoredAnnotationKeyCount?: number\n  readonly droppedAnnotationKeys?: ReadonlyArray<string>\n  readonly droppedAnnotationKeyCount?: number\n  readonly droppedAnnotationValues?: number\n  readonly droppedAnnotationNonSerializable?: number\n  readonly droppedAnnotationDepthExceeded?: number\n  readonly droppedAnnotationNonFiniteNumber?: number\n}>\n\nexport type TraitMetaConflict = Readonly<{\n  readonly origin: string\n  readonly meta: TraitMeta\n}>\n\nconst uniqSortedStrings = (input: ReadonlyArray<string>): ReadonlyArray<string> => {\n  const set = new Set<string>()\n  for (const item of input) {\n    const v = item.trim()\n    if (!v) continue\n    set.add(v)\n  }\n  return Array.from(set).sort()\n}\n\nconst isPlainRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\ntype SanitizeJsonValueStats = {\n  dropped: number\n  nonSerializable: number\n  depthExceeded: number\n  nonFiniteNumber: number\n}\n\nconst sanitizeJsonValue = (input: unknown, depth: number, stats: SanitizeJsonValueStats): JsonValue | undefined => {\n  if (input === null) return null\n\n  if (typeof input === 'string') return input\n  if (typeof input === 'boolean') return input\n  if (typeof input === 'number') {\n    if (!Number.isFinite(input)) {\n      stats.dropped += 1\n      stats.nonSerializable += 1\n      stats.nonFiniteNumber += 1\n      return undefined\n    }\n    return input\n  }\n\n  if (depth >= 6) {\n    stats.dropped += 1\n    stats.depthExceeded += 1\n    return undefined\n  }\n\n  if (Array.isArray(input)) {\n    const out: Array<JsonValue> = []\n    for (const item of input) {\n      const v = sanitizeJsonValue(item, depth + 1, stats)\n      if (v !== undefined) out.push(v)\n    }\n    return out\n  }\n\n  if (isPlainRecord(input)) {\n    const keys = Object.keys(input).sort()\n    const out: Record<string, JsonValue> = {}\n    for (const key of keys) {\n      const v = sanitizeJsonValue(input[key], depth + 1, stats)\n      if (v !== undefined) out[key] = v\n    }\n    return out\n  }\n\n  stats.dropped += 1\n  stats.nonSerializable += 1\n  return undefined\n}\n\nconst pushSample = (target: Array<string>, value: string, limit: number): void => {\n  if (target.length >= limit) return\n  target.push(value)\n}\n\nexport const sanitizeWithReport = (input: unknown): Readonly<{\n  readonly meta?: TraitMeta\n  readonly report?: TraitMetaSanitizeReport\n}> => {\n  if (input === null || input === undefined) return {}\n  if (typeof input !== 'object' || Array.isArray(input)) {\n    return { report: { invalidInput: true } }\n  }\n\n  const record = input as Record<string, unknown>\n  const out: Record<string, unknown> = {}\n\n  const reportUnknownKeys: Array<string> = []\n  let unknownKeyCount = 0\n  const reportDroppedKeys: Array<string> = []\n  let droppedTagItems = 0\n\n  const reportIgnoredAnnotationKeys: Array<string> = []\n  let ignoredAnnotationKeyCount = 0\n  const reportDroppedAnnotationKeys: Array<string> = []\n  let droppedAnnotationKeyCount = 0\n  const stats: SanitizeJsonValueStats = { dropped: 0, nonSerializable: 0, depthExceeded: 0, nonFiniteNumber: 0 }\n\n  const allowed = new Set([\n    'label',\n    'description',\n    'group',\n    'docsUrl',\n    'cacheGroup',\n    'canonical',\n    'tags',\n    'annotations',\n  ])\n\n  for (const key of Object.keys(record)) {\n    if (allowed.has(key) || key.startsWith('x-')) continue\n    unknownKeyCount += 1\n    pushSample(reportUnknownKeys, key, 8)\n  }\n\n  const pickString = (key: keyof TraitMeta): void => {\n    const value = record[key as string]\n    if (typeof value !== 'string') return\n    const trimmed = value.trim()\n    if (!trimmed) return\n    out[key] = trimmed\n  }\n\n  pickString('label')\n  pickString('description')\n  pickString('group')\n  pickString('docsUrl')\n  pickString('cacheGroup')\n\n  const canonical = record.canonical\n  if (canonical !== undefined && canonical !== null && typeof canonical !== 'boolean') {\n    pushSample(reportDroppedKeys, 'canonical', 8)\n  } else if (typeof canonical === 'boolean') {\n    out.canonical = canonical\n  }\n\n  const tagsRaw = record.tags\n  if (typeof tagsRaw === 'string') {\n    const tags = uniqSortedStrings([tagsRaw])\n    if (tags.length > 0) out.tags = tags\n  } else if (Array.isArray(tagsRaw)) {\n    const raw = tagsRaw.filter((x): x is string => typeof x === 'string')\n    droppedTagItems += tagsRaw.length - raw.length\n    const tags = uniqSortedStrings(raw)\n    if (tags.length > 0) out.tags = tags\n    // count empty/whitespace tags dropped by uniqSortedStrings\n    droppedTagItems += raw.length - tags.length\n  } else if (tagsRaw !== undefined && tagsRaw !== null) {\n    pushSample(reportDroppedKeys, 'tags', 8)\n  }\n\n  const annotations: Record<string, JsonValue> = {}\n\n  // legacy: allow passing `x-*` keys at the top-level (untyped input), then normalize into `annotations`.\n  const annotationKeys = Object.keys(record)\n    .filter((k) => k.startsWith('x-'))\n    .sort()\n  for (const key of annotationKeys) {\n    const v = sanitizeJsonValue(record[key], 0, stats)\n    if (v !== undefined) {\n      annotations[key] = v\n    } else {\n      droppedAnnotationKeyCount += 1\n      pushSample(reportDroppedAnnotationKeys, key, 8)\n    }\n  }\n\n  // preferred: typed `annotations` field (only accepts `x-*` keys).\n  const annotationsRaw = record.annotations\n  if (annotationsRaw !== undefined && annotationsRaw !== null && !isPlainRecord(annotationsRaw)) {\n    pushSample(reportDroppedKeys, 'annotations', 8)\n  } else if (isPlainRecord(annotationsRaw)) {\n    const keys = Object.keys(annotationsRaw)\n      .sort()\n    for (const key of keys) {\n      if (!key.startsWith('x-')) {\n        ignoredAnnotationKeyCount += 1\n        pushSample(reportIgnoredAnnotationKeys, key, 8)\n        continue\n      }\n\n      const v = sanitizeJsonValue(annotationsRaw[key], 0, stats)\n      if (v !== undefined) {\n        annotations[key] = v\n      } else {\n        droppedAnnotationKeyCount += 1\n        pushSample(reportDroppedAnnotationKeys, key, 8)\n      }\n    }\n  }\n\n  if (Object.keys(annotations).length > 0) out.annotations = annotations\n\n  // Dropped keys for invalid string fields (only track invalid types; empty string is ignored as low-signal).\n  for (const key of ['label', 'description', 'group', 'docsUrl', 'cacheGroup'] as const) {\n    const value = record[key]\n    if (value !== undefined && value !== null && typeof value !== 'string') {\n      pushSample(reportDroppedKeys, key, 8)\n    }\n  }\n\n  const meta = Object.keys(out).length > 0 ? (out as TraitMeta) : undefined\n\n  const report: TraitMetaSanitizeReport | undefined = (() => {\n    const hasUnknownKeys = unknownKeyCount > 0\n    const hasDroppedKeys = reportDroppedKeys.length > 0\n    const hasDroppedTagItems = droppedTagItems > 0\n    const hasIgnoredAnnotationKeys = ignoredAnnotationKeyCount > 0\n    const hasDroppedAnnotations = droppedAnnotationKeyCount > 0 || stats.dropped > 0\n\n    if (\n      !hasUnknownKeys &&\n      !hasDroppedKeys &&\n      !hasDroppedTagItems &&\n      !hasIgnoredAnnotationKeys &&\n      !hasDroppedAnnotations\n    ) {\n      return undefined\n    }\n\n    return {\n      ...(hasUnknownKeys ? { unknownKeys: reportUnknownKeys, unknownKeyCount } : {}),\n      ...(hasDroppedKeys ? { droppedKeys: uniqSortedStrings(reportDroppedKeys) } : {}),\n      ...(hasDroppedTagItems ? { droppedTagItems } : {}),\n      ...(hasIgnoredAnnotationKeys\n        ? { ignoredAnnotationKeys: uniqSortedStrings(reportIgnoredAnnotationKeys), ignoredAnnotationKeyCount }\n        : {}),\n      ...(hasDroppedAnnotations\n        ? {\n            droppedAnnotationKeys: uniqSortedStrings(reportDroppedAnnotationKeys),\n            droppedAnnotationKeyCount,\n            droppedAnnotationValues: stats.dropped,\n            droppedAnnotationNonSerializable: stats.nonSerializable,\n            droppedAnnotationDepthExceeded: stats.depthExceeded,\n            droppedAnnotationNonFiniteNumber: stats.nonFiniteNumber,\n          }\n        : {}),\n    } satisfies TraitMetaSanitizeReport\n  })()\n\n  return report ? { meta, report } : { meta }\n}\n\nexport const sanitize = (input: unknown): TraitMeta | undefined => sanitizeWithReport(input).meta\n\nconst stableStringify = (meta: TraitMeta): string => {\n  const out: Record<string, unknown> = {}\n  const keys = Object.keys(meta).sort()\n  for (const k of keys) {\n    out[k] = (meta as any)[k]\n  }\n  return JSON.stringify(out)\n}\n\nexport const equals = (a: TraitMeta | undefined, b: TraitMeta | undefined): boolean => {\n  if (a === b) return true\n  if (!a || !b) return false\n  return stableStringify(a) === stableStringify(b)\n}\n\nexport type CanonicalMergeInput = Readonly<{\n  readonly meta?: TraitMeta\n  readonly origin?: string\n  readonly conflicts?: ReadonlyArray<TraitMetaConflict>\n}>\n\nexport type CanonicalMergeResult = Readonly<{\n  readonly meta?: TraitMeta\n  readonly origin?: string\n  readonly conflicts?: ReadonlyArray<TraitMetaConflict>\n}>\n\nexport const mergeCanonical = (\n  current: CanonicalMergeInput,\n  incoming: Readonly<{ readonly origin: string; readonly meta: TraitMeta }>,\n): CanonicalMergeResult => {\n  const existing = current.meta\n  if (!existing) {\n    return {\n      meta: incoming.meta,\n      origin: incoming.origin,\n      conflicts: current.conflicts,\n    }\n  }\n\n  if (equals(existing, incoming.meta)) {\n    return current\n  }\n\n  const conflicts: Array<TraitMetaConflict> = [...((current.conflicts ?? []) as ReadonlyArray<TraitMetaConflict>)]\n\n  const push = (conflict: TraitMetaConflict): void => {\n    const exists = conflicts.some((c) => c.origin === conflict.origin && equals(c.meta, conflict.meta))\n    if (!exists) conflicts.push(conflict)\n  }\n\n  const existingCanonical = existing.canonical === true\n  const incomingCanonical = incoming.meta.canonical === true\n\n  if (!existingCanonical && incomingCanonical) {\n    push({\n      origin: current.origin ?? 'unknown',\n      meta: existing,\n    })\n    return {\n      meta: incoming.meta,\n      origin: incoming.origin,\n      conflicts,\n    }\n  }\n\n  push({\n    origin: incoming.origin,\n    meta: incoming.meta,\n  })\n\n  return {\n    meta: existing,\n    origin: current.origin ?? incoming.origin,\n    conflicts,\n  }\n}\n"],
  "mappings": "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",
  "names": []
}
