@workglow/util 0.0.85 → 0.0.87

package/dist/bun.js

@@ -78,6 +78,19 @@ class ServiceRegistry {
   }
 }
 var globalServiceRegistry = new ServiceRegistry(globalContainer);
+
+// src/di/InputResolverRegistry.ts
+var INPUT_RESOLVERS = createServiceToken("task.input.resolvers");
+if (!globalServiceRegistry.has(INPUT_RESOLVERS)) {
+  globalServiceRegistry.register(INPUT_RESOLVERS, () => new Map, true);
+}
+function getInputResolvers() {
+  return globalServiceRegistry.get(INPUT_RESOLVERS);
+}
+function registerInputResolver(formatPrefix, resolver) {
+  const resolvers = getInputResolvers();
+  resolvers.set(formatPrefix, resolver);
+}
 // src/events/EventEmitter.ts
 class EventEmitter {
   listeners = {};
@@ -964,7 +977,7 @@ function areObjectSchemasSemanticallyCompatible(sourceSchema, targetSchema) {
   return areSemanticallyCompatible(sourceSchema, targetSchema);
 }
 // src/json-schema/SchemaValidation.ts
-import { compileSchema } from "json-schema-library";
+import { compileSchema } from "@sroussey/json-schema-library";
 // src/utilities/Misc.ts
 function forceArray(input) {
   if (Array.isArray(input))
@@ -1338,6 +1351,208 @@ function objectOfArraysAsArrayOfObjects(data) {
     }
   });
 }
+// 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/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);
+}
 // src/worker/WorkerManager.ts
 function extractTransferables(obj) {
   const transferables = [];
@@ -1642,16 +1857,27 @@ export {
   sleep,
   sha256,
   serialize,
+  registerInputResolver,
   parseDataUri,
   parentPort2 as parentPort,
   objectOfArraysAsArrayOfObjects,
+  normalizeNumberArray,
+  normalize,
   makeFingerprint,
+  magnitude,
+  jaccardSimilarity,
+  isTypedArray,
+  inner,
+  hammingSimilarity,
+  hammingDistance,
   globalServiceRegistry,
   globalContainer,
+  getInputResolvers,
   forceArray,
   deepEqual,
   decompress,
   createServiceToken,
+  cosineSimilarity,
   convertImageDataToUseableForm,
   compress,
   compileSchema,
@@ -1663,9 +1889,13 @@ export {
   Worker,
   WORKER_SERVER,
   WORKER_MANAGER,
+  TypedArraySchema,
+  TensorType,
+  TensorSchema,
   ServiceRegistry,
   NodeDoesntExistError,
   NodeAlreadyExistsError,
+  INPUT_RESOLVERS,
   Graph,
   FromSchemaDefaultOptions,
   EventEmitter,
@@ -1676,4 +1906,4 @@ export {
   BaseError
 };
 
-//# debugId=58B65371F37FF8D064756E2164756E21
+//# debugId=5C29A628C26F3F6064756E2164756E21