@workglow/util 0.0.122 → 0.0.123

package/dist/schema-entry.js

@@ -0,0 +1,774 @@
+// src/json-schema/FromSchema.ts
+var FromSchemaDefaultOptions = {
+  parseNotKeyword: true,
+  parseIfThenElseKeywords: true,
+  keepDefaultedPropertiesOptional: true,
+  references: false,
+  deserialize: false
+};
+// src/json-schema/SchemaUtils.ts
+function areFormatStringsCompatible(sourceFormat, targetFormat) {
+  const formatPattern = /^[a-zA-Z][a-zA-Z0-9_-]*(?::[a-zA-Z][a-zA-Z0-9_-]*)?$/;
+  if (!formatPattern.test(sourceFormat) || !formatPattern.test(targetFormat)) {
+    return "incompatible";
+  }
+  const [sourceName, sourceNarrow] = sourceFormat.split(":");
+  const [targetName, targetNarrow] = targetFormat.split(":");
+  if (sourceName !== targetName) {
+    return "incompatible";
+  }
+  if (!sourceNarrow && !targetNarrow) {
+    return "static";
+  }
+  if (sourceNarrow && !targetNarrow) {
+    return "static";
+  }
+  if (!sourceNarrow && targetNarrow) {
+    return "runtime";
+  }
+  if (sourceNarrow === targetNarrow) {
+    return "static";
+  }
+  return "incompatible";
+}
+function isTypeStaticallyCompatible(sourceType, targetType) {
+  if (!targetType) {
+    return true;
+  }
+  if (!sourceType) {
+    return false;
+  }
+  const sourceTypes = Array.isArray(sourceType) ? sourceType : [sourceType];
+  const targetTypes = Array.isArray(targetType) ? targetType : [targetType];
+  return sourceTypes.some((st) => targetTypes.includes(st));
+}
+function mergeAllOfSchemas(schemas) {
+  if (schemas.length === 0)
+    return null;
+  if (schemas.length === 1)
+    return schemas[0];
+  let merged = {};
+  for (const schema of schemas) {
+    if (typeof schema === "boolean") {
+      if (schema === false)
+        return false;
+      continue;
+    }
+    const schemaObj = schema;
+    if (schemaObj.type !== undefined) {
+      if (merged.type === undefined) {
+        merged.type = schemaObj.type;
+      } else if (merged.type !== schemaObj.type) {
+        const mergedTypes = Array.isArray(merged.type) ? merged.type : [merged.type];
+        const schemaTypes = Array.isArray(schemaObj.type) ? schemaObj.type : [schemaObj.type];
+        const commonTypes = mergedTypes.filter((t) => schemaTypes.includes(t));
+        if (commonTypes.length === 0) {
+          return false;
+        }
+        merged.type = commonTypes.length === 1 ? commonTypes[0] : commonTypes;
+      }
+    }
+    const schemaFormat = schemaObj.format;
+    const mergedFormat = merged.format;
+    if (schemaFormat) {
+      if (!mergedFormat) {
+        merged.format = schemaFormat;
+      } else {
+        const formatCompat = areFormatStringsCompatible(mergedFormat, schemaFormat);
+        if (formatCompat === "incompatible") {
+          return false;
+        }
+        const mergedHasNarrow = mergedFormat.includes(":");
+        const schemaHasNarrow = schemaFormat.includes(":");
+        if (schemaHasNarrow && !mergedHasNarrow) {
+          merged.format = schemaFormat;
+        } else if (!schemaHasNarrow && mergedHasNarrow) {} else if (mergedFormat !== schemaFormat) {
+          return false;
+        }
+      }
+    }
+    if (schemaObj.properties && typeof schemaObj.properties === "object") {
+      if (!merged.properties) {
+        merged.properties = {};
+      }
+      const mergedProps = merged.properties;
+      const schemaProps = schemaObj.properties;
+      for (const [key, value] of Object.entries(schemaProps)) {
+        if (mergedProps[key]) {
+          const nestedMerged = mergeAllOfSchemas([mergedProps[key], value]);
+          if (nestedMerged === null || nestedMerged === false) {
+            return false;
+          }
+          mergedProps[key] = nestedMerged;
+        } else {
+          mergedProps[key] = value;
+        }
+      }
+    }
+    if (schemaObj.required && Array.isArray(schemaObj.required)) {
+      if (!merged.required) {
+        merged.required = [];
+      }
+      const mergedRequired = merged.required;
+      const schemaRequired = schemaObj.required;
+      merged.required = mergedRequired.filter((r) => schemaRequired.includes(r));
+    }
+    if (schemaObj.additionalProperties !== undefined) {
+      if (merged.additionalProperties === undefined) {
+        merged.additionalProperties = schemaObj.additionalProperties;
+      } else if (merged.additionalProperties === true && schemaObj.additionalProperties === false) {
+        merged.additionalProperties = false;
+      }
+    }
+    if (schemaObj.items !== undefined) {
+      if (merged.items === undefined) {
+        merged.items = schemaObj.items;
+      } else {
+        const mergedItems = mergeAllOfSchemas([
+          merged.items,
+          schemaObj.items
+        ]);
+        if (mergedItems === null || mergedItems === false) {
+          return false;
+        }
+        merged.items = mergedItems;
+      }
+    }
+  }
+  return merged;
+}
+function isCompatibleWithUnion(sourceSchema, unionSchemas) {
+  let hasStatic = false;
+  let hasRuntime = false;
+  for (const unionSchema of unionSchemas) {
+    const compatibility = areSemanticallyCompatible(sourceSchema, unionSchema);
+    if (compatibility === "static") {
+      hasStatic = true;
+    } else if (compatibility === "runtime") {
+      hasRuntime = true;
+    }
+  }
+  if (hasStatic)
+    return "static";
+  if (hasRuntime)
+    return "runtime";
+  return "incompatible";
+}
+function areSemanticallyCompatible(sourceSchema, targetSchema) {
+  if (sourceSchema === undefined || targetSchema === undefined) {
+    return "incompatible";
+  }
+  if (typeof targetSchema === "boolean") {
+    if (targetSchema === false)
+      return "incompatible";
+    if (targetSchema === true)
+      return "static";
+    return "incompatible";
+  }
+  if (typeof sourceSchema === "boolean") {
+    if (sourceSchema === false)
+      return "incompatible";
+    if (sourceSchema === true)
+      return "runtime";
+  }
+  if (sourceSchema.allOf && Array.isArray(sourceSchema.allOf)) {
+    const mergedSchema = mergeAllOfSchemas(sourceSchema.allOf);
+    if (mergedSchema === null || mergedSchema === false) {
+      return "incompatible";
+    }
+    return areSemanticallyCompatible(mergedSchema, targetSchema);
+  }
+  const sourceType = sourceSchema.type;
+  const targetType = targetSchema.type;
+  if (sourceSchema.oneOf && Array.isArray(sourceSchema.oneOf)) {
+    let hasStatic = false;
+    let hasRuntime = false;
+    for (const sourceOption of sourceSchema.oneOf) {
+      const compatibility = areSemanticallyCompatible(sourceOption, targetSchema);
+      if (compatibility === "static") {
+        hasStatic = true;
+      } else if (compatibility === "runtime") {
+        hasRuntime = true;
+      }
+    }
+    if (hasRuntime)
+      return "runtime";
+    if (hasStatic)
+      return "static";
+    return "incompatible";
+  }
+  if (sourceSchema.anyOf && Array.isArray(sourceSchema.anyOf)) {
+    let hasStatic = false;
+    let hasRuntime = false;
+    for (const sourceOption of sourceSchema.anyOf) {
+      const compatibility = areSemanticallyCompatible(sourceOption, targetSchema);
+      if (compatibility === "static") {
+        hasStatic = true;
+      } else if (compatibility === "runtime") {
+        hasRuntime = true;
+      }
+    }
+    if (hasRuntime)
+      return "runtime";
+    if (hasStatic)
+      return "static";
+    return "incompatible";
+  }
+  if (targetSchema.oneOf && Array.isArray(targetSchema.oneOf)) {
+    return isCompatibleWithUnion(sourceSchema, targetSchema.oneOf);
+  }
+  if (targetSchema.anyOf && Array.isArray(targetSchema.anyOf)) {
+    return isCompatibleWithUnion(sourceSchema, targetSchema.anyOf);
+  }
+  if (targetSchema.allOf && Array.isArray(targetSchema.allOf)) {
+    let hasStatic = false;
+    let hasRuntime = false;
+    for (const allOfSchema of targetSchema.allOf) {
+      const compatibility = areSemanticallyCompatible(sourceSchema, allOfSchema);
+      if (compatibility === "incompatible") {
+        return "incompatible";
+      } else if (compatibility === "static") {
+        hasStatic = true;
+      } else if (compatibility === "runtime") {
+        hasRuntime = true;
+      }
+    }
+    if (hasRuntime)
+      return "runtime";
+    if (hasStatic)
+      return "static";
+    return "incompatible";
+  }
+  if (sourceType === "object" && targetType === "object") {
+    const sourceProperties = sourceSchema.properties;
+    const targetProperties = targetSchema.properties;
+    if (!targetProperties) {
+      return "static";
+    }
+    if (!sourceProperties) {
+      if (targetSchema.additionalProperties === false) {
+        return "incompatible";
+      }
+      return "static";
+    }
+    const targetRequired = targetSchema.required || [];
+    let hasStatic = true;
+    let hasRuntime = false;
+    for (const propName of targetRequired) {
+      const targetProp = targetProperties?.[propName];
+      const sourceProp = sourceProperties?.[propName];
+      if (!sourceProp) {
+        return "incompatible";
+      }
+      if (targetProp) {
+        const propCompatibility = areSemanticallyCompatible(sourceProp, targetProp);
+        if (propCompatibility === "incompatible") {
+          return "incompatible";
+        } else if (propCompatibility === "runtime") {
+          hasRuntime = true;
+          hasStatic = false;
+        }
+      }
+    }
+    if (targetSchema.additionalProperties === false) {
+      const sourcePropNames = Object.keys(sourceProperties);
+      const targetPropNames = Object.keys(targetProperties);
+      const extraProps = sourcePropNames.filter((name) => !targetPropNames.includes(name));
+      if (extraProps.length > 0) {
+        return "incompatible";
+      }
+    }
+    if (hasRuntime)
+      return "runtime";
+    return "static";
+  }
+  if (sourceType === "array" && targetType === "array") {
+    const sourceFormat2 = sourceSchema?.format;
+    const targetFormat2 = targetSchema?.format;
+    let formatCompatibility = null;
+    if (sourceFormat2 && targetFormat2) {
+      formatCompatibility = areFormatStringsCompatible(sourceFormat2, targetFormat2);
+      if (formatCompatibility === "incompatible") {
+        return "incompatible";
+      }
+    }
+    if (sourceFormat2 && !targetFormat2) {
+      return "static";
+    }
+    if (!sourceFormat2 && targetFormat2) {
+      return "incompatible";
+    }
+    const sourceItems = sourceSchema.items;
+    const targetItems = targetSchema.items;
+    if (sourceItems && typeof sourceItems === "object" && !Array.isArray(sourceItems) && targetItems && typeof targetItems === "object" && !Array.isArray(targetItems)) {
+      const itemsCompatibility = areSemanticallyCompatible(sourceItems, targetItems);
+      if (formatCompatibility === "runtime") {
+        return "runtime";
+      }
+      return itemsCompatibility;
+    }
+    if (!targetItems) {
+      return "static";
+    }
+    if (!sourceItems) {
+      return "incompatible";
+    }
+    if (Array.isArray(targetItems)) {
+      return isCompatibleWithUnion(sourceItems, targetItems);
+    }
+    return "static";
+  }
+  if (!sourceType) {
+    const targetFormat2 = targetSchema?.format;
+    if (targetFormat2) {
+      return "runtime";
+    }
+    return "static";
+  }
+  if (!targetType) {
+    const targetFormat2 = targetSchema?.format;
+    if (targetFormat2) {
+      const sourceFormat2 = sourceSchema?.format;
+      if (!sourceFormat2) {
+        return "incompatible";
+      }
+      return areFormatStringsCompatible(sourceFormat2, targetFormat2);
+    }
+    return "static";
+  }
+  if (!isTypeStaticallyCompatible(sourceType, targetType)) {
+    return "incompatible";
+  }
+  const sourceFormat = sourceSchema?.format;
+  const targetFormat = targetSchema?.format;
+  if (sourceFormat && targetFormat) {
+    return areFormatStringsCompatible(sourceFormat, targetFormat);
+  }
+  if (sourceFormat && !targetFormat) {
+    return "static";
+  }
+  if (!sourceFormat && targetFormat) {
+    return "incompatible";
+  }
+  return "static";
+}
+function areObjectSchemasSemanticallyCompatible(sourceSchema, targetSchema) {
+  return areSemanticallyCompatible(sourceSchema, targetSchema);
+}
+// src/json-schema/SchemaValidation.ts
+import { compileSchema } from "@sroussey/json-schema-library";
+// src/json-schema/parsePartialJson.ts
+function parsePartialJson(text) {
+  const trimmed = text.trim();
+  if (!trimmed)
+    return;
+  try {
+    const result = JSON.parse(trimmed);
+    if (typeof result === "object" && result !== null && !Array.isArray(result)) {
+      return result;
+    }
+    return;
+  } catch {}
+  if (trimmed[0] !== "{")
+    return;
+  const repaired = repairJson(trimmed);
+  if (repaired === undefined)
+    return;
+  try {
+    const result = JSON.parse(repaired);
+    if (typeof result === "object" && result !== null && !Array.isArray(result)) {
+      return result;
+    }
+    return;
+  } catch {
+    return;
+  }
+}
+function repairJson(text) {
+  let result = "";
+  let i = 0;
+  const len = text.length;
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  let lastSafeEnd = 0;
+  while (i < len) {
+    const ch = text[i];
+    if (escaped) {
+      escaped = false;
+      result += ch;
+      i++;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      result += ch;
+      i++;
+      continue;
+    }
+    if (inString) {
+      if (ch === '"') {
+        inString = false;
+        result += ch;
+        i++;
+        lastSafeEnd = result.length;
+        continue;
+      }
+      result += ch;
+      i++;
+      continue;
+    }
+    switch (ch) {
+      case '"':
+        inString = true;
+        result += ch;
+        i++;
+        break;
+      case "{":
+        stack.push("}");
+        result += ch;
+        i++;
+        break;
+      case "[":
+        stack.push("]");
+        result += ch;
+        i++;
+        break;
+      case "}":
+        if (stack.length > 0 && stack[stack.length - 1] === "}") {
+          stack.pop();
+          result += ch;
+          i++;
+          lastSafeEnd = result.length;
+        } else {
+          return closeStack(result, stack);
+        }
+        break;
+      case "]":
+        if (stack.length > 0 && stack[stack.length - 1] === "]") {
+          stack.pop();
+          result += ch;
+          i++;
+          lastSafeEnd = result.length;
+        } else {
+          return closeStack(result, stack);
+        }
+        break;
+      default:
+        result += ch;
+        i++;
+        break;
+    }
+  }
+  if (inString) {
+    result += '"';
+  }
+  if (stack.length === 0) {
+    return result;
+  }
+  return closeStack(cleanTrailing(result), stack);
+}
+function cleanTrailing(text) {
+  let s = text.trimEnd();
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const trimmed = s.trimEnd();
+    if (trimmed.endsWith(",")) {
+      s = trimmed.slice(0, -1);
+      changed = true;
+      continue;
+    }
+    if (trimmed.endsWith(":")) {
+      const withoutColon = trimmed.slice(0, -1).trimEnd();
+      if (withoutColon.endsWith('"')) {
+        const keyStart = withoutColon.lastIndexOf('"', withoutColon.length - 2);
+        if (keyStart >= 0) {
+          let before = withoutColon.slice(0, keyStart).trimEnd();
+          if (before.endsWith(",")) {
+            before = before.slice(0, -1);
+          }
+          s = before;
+          changed = true;
+          continue;
+        }
+      }
+      s = withoutColon;
+      changed = true;
+      continue;
+    }
+    const bareTokenMatch = trimmed.match(/,\s*"[^"]*"\s*:\s*(?:tru|fal|nul|true|false|null|[\d.eE+-]+)$/);
+    if (bareTokenMatch) {
+      const valueStr = trimmed.slice(trimmed.lastIndexOf(":") + 1).trim();
+      try {
+        JSON.parse(valueStr);
+      } catch {
+        s = trimmed.slice(0, bareTokenMatch.index).trimEnd();
+        if (s.endsWith(","))
+          s = s.slice(0, -1);
+        changed = true;
+        continue;
+      }
+    }
+  }
+  return s;
+}
+function closeStack(text, stack) {
+  let result = text;
+  for (let i = stack.length - 1;i >= 0; i--) {
+    result += stack[i];
+  }
+  return result;
+}
+// src/vector/TypedArray.ts
+function isTypedArray(value) {
+  return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+var TypedArrayType = null;
+var TypedArraySchemaOptions = {
+  ...FromSchemaDefaultOptions,
+  deserialize: [
+    {
+      pattern: { type: "array", format: "TypedArray:Float64Array" },
+      output: Float64Array
+    },
+    {
+      pattern: { type: "array", format: "TypedArray:Float32Array" },
+      output: Float32Array
+    },
+    {
+      pattern: { type: "array", format: "TypedArray:Float16Array" },
+      output: Float16Array
+    },
+    {
+      pattern: { type: "array", format: "TypedArray:Int16Array" },
+      output: Int16Array
+    },
+    {
+      pattern: { type: "array", format: "TypedArray:Int8Array" },
+      output: Int8Array
+    },
+    {
+      pattern: { type: "array", format: "TypedArray:Uint8Array" },
+      output: Uint8Array
+    },
+    {
+      pattern: { type: "array", format: "TypedArray:Uint16Array" },
+      output: Uint16Array
+    },
+    {
+      pattern: { type: "array", format: "TypedArray" },
+      output: TypedArrayType
+    }
+  ]
+};
+var TypedArraySchema = (annotations = {}) => {
+  return {
+    type: "array",
+    format: "TypedArray",
+    title: "Typed Array",
+    description: "A typed array (Float32Array, Int8Array, etc.)",
+    ...annotations
+  };
+};
+
+// src/vector/Tensor.ts
+var TensorType = {
+  FLOAT16: "float16",
+  FLOAT32: "float32",
+  FLOAT64: "float64",
+  INT8: "int8",
+  UINT8: "uint8",
+  INT16: "int16",
+  UINT16: "uint16"
+};
+var TensorSchema = (annotations = {}) => ({
+  type: "object",
+  properties: {
+    type: {
+      type: "string",
+      enum: Object.values(TensorType),
+      title: "Type",
+      description: "The type of the tensor"
+    },
+    data: TypedArraySchema({
+      title: "Data",
+      description: "The data of the tensor"
+    }),
+    shape: {
+      type: "array",
+      items: { type: "number" },
+      title: "Shape",
+      description: "The shape of the tensor (dimensions)",
+      minItems: 1,
+      default: [1]
+    },
+    normalized: {
+      type: "boolean",
+      title: "Normalized",
+      description: "Whether the tensor data is normalized",
+      default: false
+    }
+  },
+  required: ["data"],
+  additionalProperties: false,
+  ...annotations
+});
+// src/vector/TypedArrayUtils.ts
+var WIDTH_RANK = {
+  Float64Array: 6,
+  Float32Array: 5,
+  Float16Array: 4,
+  Int16Array: 3,
+  Uint16Array: 3,
+  Int8Array: 2,
+  Uint8Array: 2
+};
+function getWidthRank(arr) {
+  return WIDTH_RANK[arr.constructor.name] ?? 0;
+}
+function widestConstructor(sources) {
+  let best = sources[0];
+  for (let i = 1;i < sources.length; i++) {
+    if (getWidthRank(sources[i]) > getWidthRank(best))
+      best = sources[i];
+  }
+  return best.constructor;
+}
+function createTypedArrayFrom(sources, values) {
+  const Ctor = widestConstructor(sources);
+  const result = new Ctor(values.length);
+  for (let i = 0;i < values.length; i++)
+    result[i] = values[i];
+  return result;
+}
+// src/vector/VectorSimilarityUtils.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Vectors must have the same length");
+  }
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0;i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denominator === 0) {
+    return 0;
+  }
+  return dotProduct / denominator;
+}
+function jaccardSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Vectors must have the same length");
+  }
+  let globalMin = a[0];
+  for (let i = 0;i < a.length; i++) {
+    globalMin = Math.min(globalMin, a[i], b[i]);
+  }
+  const shift = globalMin < 0 ? -globalMin : 0;
+  let minSum = 0;
+  let maxSum = 0;
+  for (let i = 0;i < a.length; i++) {
+    const shiftedA = a[i] + shift;
+    const shiftedB = b[i] + shift;
+    minSum += Math.min(shiftedA, shiftedB);
+    maxSum += Math.max(shiftedA, shiftedB);
+  }
+  return maxSum === 0 ? 0 : minSum / maxSum;
+}
+function hammingDistance(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Vectors must have the same length");
+  }
+  let differences = 0;
+  for (let i = 0;i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      differences++;
+    }
+  }
+  return differences / a.length;
+}
+function hammingSimilarity(a, b) {
+  return 1 - hammingDistance(a, b);
+}
+// src/vector/VectorUtils.ts
+function magnitude(arr) {
+  return Math.sqrt(arr.reduce((acc, val) => acc + val * val, 0));
+}
+function inner(arr1, arr2) {
+  if (arr1.length !== arr2.length) {
+    throw new Error("Vectors must have the same length to compute inner product.");
+  }
+  return arr1.reduce((acc, val, i) => acc + val * arr2[i], 0);
+}
+function normalize(vector, throwOnZero = true, float32 = false) {
+  const mag = magnitude(vector);
+  if (mag === 0) {
+    if (throwOnZero) {
+      throw new Error("Cannot normalize a zero vector.");
+    }
+    return vector;
+  }
+  const normalized = Array.from(vector).map((val) => Number(val) / mag);
+  if (float32) {
+    return new Float32Array(normalized);
+  }
+  if (vector instanceof Float64Array) {
+    return new Float64Array(normalized);
+  }
+  if (vector instanceof Float16Array) {
+    return new Float16Array(normalized);
+  }
+  if (vector instanceof Float32Array) {
+    return new Float32Array(normalized);
+  }
+  if (vector instanceof Int8Array) {
+    return new Int8Array(normalized);
+  }
+  if (vector instanceof Uint8Array) {
+    return new Uint8Array(normalized);
+  }
+  if (vector instanceof Int16Array) {
+    return new Int16Array(normalized);
+  }
+  if (vector instanceof Uint16Array) {
+    return new Uint16Array(normalized);
+  }
+  return new Float32Array(normalized);
+}
+function normalizeNumberArray(values, throwOnZero = false) {
+  const norm = magnitude(values);
+  if (norm === 0) {
+    if (throwOnZero) {
+      throw new Error("Cannot normalize a zero vector.");
+    }
+    return values;
+  }
+  return values.map((v) => v / norm);
+}
+export {
+  parsePartialJson,
+  normalizeNumberArray,
+  normalize,
+  magnitude,
+  jaccardSimilarity,
+  isTypedArray,
+  inner,
+  hammingSimilarity,
+  hammingDistance,
+  createTypedArrayFrom,
+  cosineSimilarity,
+  compileSchema,
+  areSemanticallyCompatible,
+  areObjectSchemasSemanticallyCompatible,
+  TypedArraySchema,
+  TensorType,
+  TensorSchema,
+  FromSchemaDefaultOptions
+};
+
+//# debugId=56A406BAD97EBABB64756E2164756E21