@lov3kaizen/agentsea-embeddings 0.5.1

package/dist/caching/index.mjs

@@ -0,0 +1,27 @@
+import {
+  BaseCache,
+  MemoryCache,
+  RedisCache,
+  SQLiteCache,
+  TieredCache,
+  createCache,
+  createMemoryCache,
+  createRedisCache,
+  createSQLiteCache,
+  createStandardTieredCache,
+  createTieredCache
+} from "../chunk-VPSMDBHH.mjs";
+import "../chunk-3KM32UQK.mjs";
+export {
+  BaseCache,
+  MemoryCache,
+  RedisCache,
+  SQLiteCache,
+  TieredCache,
+  createCache,
+  createMemoryCache,
+  createRedisCache,
+  createSQLiteCache,
+  createStandardTieredCache,
+  createTieredCache
+};

package/dist/chunk-3KM32UQK.mjs

@@ -0,0 +1,207 @@
+// src/core/utils.ts
+import { createHash } from "crypto";
+function contentHash(text, algorithm = "sha256") {
+  return createHash(algorithm).update(text).digest("hex");
+}
+function cacheKey(text, model, prefix = "emb") {
+  const hash = contentHash(`${model}:${text}`);
+  return `${prefix}:${model}:${hash}`;
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function splitByChars(text, maxChars, overlap = 0) {
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    const end = Math.min(start + maxChars, text.length);
+    chunks.push(text.slice(start, end));
+    start = end - overlap;
+    if (start >= text.length) break;
+  }
+  return chunks;
+}
+function splitBySeparator(text, separator) {
+  return text.split(separator).filter((s) => s.trim().length > 0);
+}
+function batch(items, batchSize) {
+  const batches = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    batches.push(items.slice(i, i + batchSize));
+  }
+  return batches;
+}
+async function withConcurrency(items, fn, concurrency) {
+  const results = new Array(items.length);
+  let currentIndex = 0;
+  async function worker() {
+    while (currentIndex < items.length) {
+      const index = currentIndex++;
+      results[index] = await fn(items[index], index);
+    }
+  }
+  const workers = Array.from(
+    { length: Math.min(concurrency, items.length) },
+    () => worker()
+  );
+  await Promise.all(workers);
+  return results;
+}
+async function retry(fn, options = {}) {
+  const {
+    maxRetries = 3,
+    initialDelay = 1e3,
+    maxDelay = 3e4,
+    backoffMultiplier = 2,
+    retryCondition = () => true
+  } = options;
+  let lastError;
+  let delay = initialDelay;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === maxRetries || !retryCondition(lastError)) {
+        throw lastError;
+      }
+      await sleep(delay);
+      delay = Math.min(delay * backoffMultiplier, maxDelay);
+    }
+  }
+  throw lastError;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+function percentile(values, p) {
+  if (values.length === 0) return 0;
+  if (p < 0 || p > 100) throw new Error("Percentile must be between 0 and 100");
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = p / 100 * (sorted.length - 1);
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  if (lower === upper) {
+    return sorted[lower];
+  }
+  const weight = index - lower;
+  return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+}
+function mean(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((sum, v) => sum + v, 0) / values.length;
+}
+function variance(values) {
+  if (values.length === 0) return 0;
+  const m = mean(values);
+  return values.reduce((sum, v) => sum + Math.pow(v - m, 2), 0) / values.length;
+}
+function stdDev(values) {
+  return Math.sqrt(variance(values));
+}
+function normalize(value, min, max) {
+  if (max === min) return 0;
+  return (value - min) / (max - min);
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function generateId(prefix = "") {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 10);
+  return prefix ? `${prefix}_${timestamp}${random}` : `${timestamp}${random}`;
+}
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+async function measureTime(fn) {
+  const start = performance.now();
+  const result = await fn();
+  const durationMs = performance.now() - start;
+  return { result, durationMs };
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  if (ms < 36e5) return `${(ms / 6e4).toFixed(1)}m`;
+  return `${(ms / 36e5).toFixed(1)}h`;
+}
+function createEventEmitter() {
+  const listeners = {};
+  return {
+    on(event, listener) {
+      if (!listeners[event]) {
+        listeners[event] = [];
+      }
+      listeners[event].push(listener);
+      return () => this.off(event, listener);
+    },
+    off(event, listener) {
+      const list = listeners[event];
+      if (list) {
+        const index = list.indexOf(listener);
+        if (index !== -1) {
+          list.splice(index, 1);
+        }
+      }
+    },
+    emit(event, ...args) {
+      const list = listeners[event];
+      if (list) {
+        for (const listener of list) {
+          listener(...args);
+        }
+      }
+    },
+    removeAllListeners(event) {
+      if (event) {
+        delete listeners[event];
+      } else {
+        for (const key of Object.keys(listeners)) {
+          delete listeners[key];
+        }
+      }
+    }
+  };
+}
+
+export {
+  contentHash,
+  cacheKey,
+  estimateTokens,
+  splitByChars,
+  splitBySeparator,
+  batch,
+  withConcurrency,
+  retry,
+  sleep,
+  deferred,
+  percentile,
+  mean,
+  variance,
+  stdDev,
+  normalize,
+  clamp,
+  generateId,
+  deepClone,
+  measureTime,
+  formatBytes,
+  formatDuration,
+  createEventEmitter
+};