@workglow/util 0.0.85 → 0.0.87

package/dist/vector/TypedArray.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FromSchema } from "../json-schema/FromSchema";
+import { JsonSchema } from "../json-schema/JsonSchema";
+/**
+ * Supported typed array types
+ * - Float16Array: 16-bit floating point (medium precision)
+ * - Float32Array: Standard 32-bit floating point (most common)
+ * - Float64Array: 64-bit floating point (high precision)
+ * - Int8Array: 8-bit signed integer (binary quantization)
+ * - Uint8Array: 8-bit unsigned integer (quantization)
+ * - Int16Array: 16-bit signed integer (quantization)
+ * - Uint16Array: 16-bit unsigned integer (quantization)
+ */
+export type TypedArray = Float32Array | Float16Array | Float64Array | Int8Array | Uint8Array | Int16Array | Uint16Array;
+export type TypedArrayString = "TypedArray" | "TypedArray:Float16Array" | "TypedArray:Float32Array" | "TypedArray:Float64Array" | "TypedArray:Int8Array" | "TypedArray:Uint8Array" | "TypedArray:Int16Array" | "TypedArray:Uint16Array";
+export declare function isTypedArray(value: unknown): value is TypedArray;
+declare const TypedArraySchemaOptions: {
+    readonly deserialize: [{
+        readonly pattern: {
+            readonly type: "array";
+            readonly format: "TypedArray:Float64Array";
+        };
+        readonly output: Float64ArrayConstructor;
+    }, {
+        readonly pattern: {
+            readonly type: "array";
+            readonly format: "TypedArray:Float32Array";
+        };
+        readonly output: Float32ArrayConstructor;
+    }, {
+        readonly pattern: {
+            readonly type: "array";
+            readonly format: "TypedArray:Float16Array";
+        };
+        readonly output: Float16ArrayConstructor;
+    }, {
+        readonly pattern: {
+            readonly type: "array";
+            readonly format: "TypedArray:Int16Array";
+        };
+        readonly output: Int16ArrayConstructor;
+    }, {
+        readonly pattern: {
+            readonly type: "array";
+            readonly format: "TypedArray:Int8Array";
+        };
+        readonly output: Int8ArrayConstructor;
+    }, {
+        readonly pattern: {
+            readonly type: "array";
+            readonly format: "TypedArray:Uint8Array";
+        };
+        readonly output: Uint8ArrayConstructor;
+    }, {
+        readonly pattern: {
+            readonly type: "array";
+            readonly format: "TypedArray:Uint16Array";
+        };
+        readonly output: Uint16ArrayConstructor;
+    }, {
+        readonly pattern: {
+            readonly type: "array";
+            readonly format: "TypedArray";
+        };
+        readonly output: TypedArray;
+    }];
+    readonly parseNotKeyword: true;
+    readonly parseIfThenElseKeywords: true;
+    readonly keepDefaultedPropertiesOptional: true;
+    readonly references: false;
+};
+export type TypedArraySchemaOptions = typeof TypedArraySchemaOptions;
+export type VectorFromSchema<SCHEMA extends JsonSchema> = FromSchema<SCHEMA, TypedArraySchemaOptions>;
+export declare const TypedArraySchema: (annotations?: Record<string, unknown>) => {
+    readonly type: "array";
+    readonly format: "TypedArray";
+    readonly title: "Typed Array";
+    readonly description: "A typed array (Float32Array, Int8Array, etc.)";
+};
+export {};
+//# sourceMappingURL=TypedArray.d.ts.map

package/dist/vector/TypedArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedArray.d.ts","sourceRoot":"","sources":["../../src/vector/TypedArray.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAA+C,MAAM,2BAA2B,CAAC;AACpG,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAEvD;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAClB,YAAY,GACZ,YAAY,GACZ,YAAY,GACZ,SAAS,GACT,UAAU,GACV,UAAU,GACV,WAAW,CAAC;AAEhB,MAAM,MAAM,gBAAgB,GACxB,YAAY,GACZ,yBAAyB,GACzB,yBAAyB,GACzB,yBAAyB,GACzB,sBAAsB,GACtB,uBAAuB,GACvB,uBAAuB,GACvB,wBAAwB,CAAC;AAE7B,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE;AAKD,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCS,CAAC;AAEvC,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC;AAErE,MAAM,MAAM,gBAAgB,CAAC,MAAM,SAAS,UAAU,IAAI,UAAU,CAClE,MAAM,EACN,uBAAuB,CACxB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,cAAa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;;;;;CAQzE,CAAC"}

package/dist/vector/VectorSimilarityUtils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { TypedArray } from "./TypedArray";
+/**
+ * Calculates cosine similarity between two vectors
+ * Returns a value between -1 and 1, where 1 means identical direction
+ */
+export declare function cosineSimilarity(a: TypedArray, b: TypedArray): number;
+/**
+ * Calculates Jaccard similarity between two vectors
+ * Uses the formula: sum(min(a[i], b[i])) / sum(max(a[i], b[i]))
+ * Returns a value between 0 and 1
+ * For negative values, normalizes by finding the global min and shifting to non-negative range
+ */
+export declare function jaccardSimilarity(a: TypedArray, b: TypedArray): number;
+/**
+ * Calculates Hamming distance between two vectors (normalized)
+ * Counts the number of positions where vectors differ
+ * Returns a value between 0 and 1 (0 = identical, 1 = completely different)
+ */
+export declare function hammingDistance(a: TypedArray, b: TypedArray): number;
+/**
+ * Calculates Hamming similarity (inverse of distance)
+ * Returns a value between 0 and 1 (1 = identical, 0 = completely different)
+ */
+export declare function hammingSimilarity(a: TypedArray, b: TypedArray): number;
+//# sourceMappingURL=VectorSimilarityUtils.d.ts.map

package/dist/vector/VectorSimilarityUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VectorSimilarityUtils.d.ts","sourceRoot":"","sources":["../../src/vector/VectorSimilarityUtils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,MAAM,CAiBrE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,MAAM,CAyBtE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,MAAM,CAcpE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,MAAM,CAEtE"}

package/dist/vector/VectorUtils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { TypedArray } from "./TypedArray";
+/**
+ * Calculates the magnitude (L2 norm) of a vector
+ */
+export declare function magnitude(arr: TypedArray | number[]): number;
+/**
+ * Calculates the inner (dot) product of two vectors
+ */
+export declare function inner(arr1: TypedArray, arr2: TypedArray): number;
+/**
+ * Normalizes a vector to unit length (L2 normalization)
+ *
+ * @param vector - The vector to normalize
+ * @param throwOnZero - If true, throws an error for zero vectors. If false, returns the original vector.
+ * @returns Normalized vector with the same type as input
+ */
+export declare function normalize(vector: TypedArray, throwOnZero?: boolean, float32?: boolean): TypedArray;
+/**
+ * Normalizes an array of numbers to unit length (L2 normalization)
+ *
+ * @param values - The array of numbers to normalize
+ * @param throwOnZero - If true, throws an error for zero vectors. If false, returns the original array.
+ * @returns Normalized array of numbers
+ */
+export declare function normalizeNumberArray(values: number[], throwOnZero?: boolean): number[];
+//# sourceMappingURL=VectorUtils.d.ts.map

package/dist/vector/VectorUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VectorUtils.d.ts","sourceRoot":"","sources":["../../src/vector/VectorUtils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,EAAE,GAAG,MAAM,CAG5D;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAMhE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,WAAW,UAAO,EAAE,OAAO,UAAQ,GAAG,UAAU,CAwC7F;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,WAAW,UAAQ,GAAG,MAAM,EAAE,CAWpF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@workglow/util",
   "type": "module",
-  "version": "0.0.85",
+  "version": "0.0.87",
   "description": "Utility functions and shared types for Workglow, providing common functionality across all packages.",
   "scripts": {
     "watch": "concurrently -c 'auto' 'bun:watch-*'",
@@ -36,7 +36,7 @@
     "access": "public"
   },
   "dependencies": {
-    "json-schema-library": "^10.5.1",
-    "@sroussey/json-schema-to-ts": "3.1.3"
+    "@sroussey/json-schema-library": "^10.5.3",
+    "@sroussey/json-schema-to-ts": "3.1.4"
   }
 }