@automatalabs/react-native-transformers 0.1.1 → 0.1.3

package/src/adapter/onnxruntime-web-webgpu.js

@@ -1,246 +0,0 @@
-const { NativeModules } = require('react-native');
-const ortReactNative = require('onnxruntime-react-native');
-const { sanitizeSessionOptions } = require('../runtime');
-
-const Module = NativeModules?.Onnxruntime;
-
-if (typeof globalThis.OrtApi === 'undefined' && typeof Module?.install === 'function') {
-  Module.install();
-}
-
-const OrtApi =
-  globalThis.OrtApi ??
-  new Proxy(
-    {},
-    {
-      get() {
-        throw new Error(
-          'OrtApi is not initialized. Please make sure Onnxruntime installation is successful.',
-        );
-      },
-    },
-  );
-
-const dataTypeStrings = [
-  undefined,
-  'float32',
-  'uint8',
-  'int8',
-  'uint16',
-  'int16',
-  'int32',
-  'int64',
-  'string',
-  'bool',
-  'float16',
-  'float64',
-  'uint32',
-  'uint64',
-  undefined,
-  undefined,
-  undefined,
-  undefined,
-  undefined,
-  undefined,
-  undefined,
-  'uint4',
-  'int4',
-];
-
-function fillNamesAndMetadata(rawMetadata = []) {
-  const names = [];
-  const metadata = [];
-
-  for (const item of rawMetadata) {
-    names.push(item.name);
-
-    if (!item.isTensor) {
-      metadata.push({
-        name: item.name,
-        isTensor: false,
-      });
-      continue;
-    }
-
-    const type = dataTypeStrings[item.type];
-    if (type === undefined) {
-      throw new Error(`Unsupported data type: ${item.type}`);
-    }
-
-    const shape = [];
-    for (let index = 0; index < item.shape.length; index += 1) {
-      const dim = item.shape[index];
-      if (dim === -1) {
-        shape.push(item.symbolicDimensions[index]);
-      } else if (dim >= 0) {
-        shape.push(dim);
-      } else {
-        throw new Error(`Invalid dimension: ${dim}`);
-      }
-    }
-
-    metadata.push({
-      name: item.name,
-      isTensor: true,
-      type,
-      shape,
-    });
-  }
-
-  return [names, metadata];
-}
-
-function getLogLevelValue(logLevel) {
-  switch (logLevel) {
-    case 'verbose':
-      return 0;
-    case 'info':
-      return 1;
-    case 'warning':
-    case undefined:
-      return 2;
-    case 'error':
-      return 3;
-    case 'fatal':
-      return 4;
-    default:
-      throw new Error(`Unsupported log level: ${logLevel}`);
-  }
-}
-
-function normalizeCreateArguments(args) {
-  const [arg0, arg1, arg2, arg3] = args;
-
-  if (typeof arg0 === 'string') {
-    if (arg1 !== undefined && (typeof arg1 !== 'object' || arg1 === null || Array.isArray(arg1))) {
-      throw new TypeError("'options' must be an object.");
-    }
-
-    return {
-      modelPath: arg0,
-      modelBytes: null,
-      options: arg1 ?? {},
-    };
-  }
-
-  if (arg0 instanceof Uint8Array) {
-    if (arg1 !== undefined && (typeof arg1 !== 'object' || arg1 === null || Array.isArray(arg1))) {
-      throw new TypeError("'options' must be an object.");
-    }
-
-    return {
-      modelPath: null,
-      modelBytes: arg0,
-      options: arg1 ?? {},
-    };
-  }
-
-  if (
-    arg0 instanceof ArrayBuffer ||
-    (typeof SharedArrayBuffer !== 'undefined' && arg0 instanceof SharedArrayBuffer)
-  ) {
-    let byteOffset = 0;
-    let byteLength = arg0.byteLength;
-    let options = {};
-
-    if (typeof arg1 === 'object' && arg1 !== null) {
-      options = arg1;
-    } else if (typeof arg1 === 'number') {
-      byteOffset = arg1;
-      byteLength = typeof arg2 === 'number' ? arg2 : arg0.byteLength - byteOffset;
-      options = typeof arg3 === 'object' && arg3 !== null ? arg3 : {};
-    } else if (arg1 !== undefined) {
-      throw new TypeError("'options' must be an object.");
-    }
-
-    return {
-      modelPath: null,
-      modelBytes: new Uint8Array(arg0, byteOffset, byteLength),
-      options,
-    };
-  }
-
-  throw new TypeError("Unexpected argument[0]: must be 'path' or 'buffer'.");
-}
-
-function toExactArrayBuffer(uint8Array) {
-  if (uint8Array.byteOffset === 0 && uint8Array.byteLength === uint8Array.buffer.byteLength) {
-    return uint8Array.buffer;
-  }
-
-  return uint8Array.buffer.slice(
-    uint8Array.byteOffset,
-    uint8Array.byteOffset + uint8Array.byteLength,
-  );
-}
-
-class ReactNativeSessionHandler {
-  #inferenceSession;
-
-  constructor(session) {
-    this.#inferenceSession = session;
-
-    const [inputNames, inputMetadata] = fillNamesAndMetadata(session.inputMetadata);
-    const [outputNames, outputMetadata] = fillNamesAndMetadata(session.outputMetadata);
-
-    this.inputNames = inputNames;
-    this.outputNames = outputNames;
-    this.inputMetadata = inputMetadata;
-    this.outputMetadata = outputMetadata;
-  }
-
-  async run(feeds, fetches, options) {
-    return this.#inferenceSession.run(feeds, fetches, options);
-  }
-
-  async dispose() {
-    this.#inferenceSession.dispose();
-  }
-
-  async release() {
-    this.#inferenceSession.dispose();
-  }
-
-  startProfiling() {
-    // no-op; profiling is enabled at load time by session options if requested
-  }
-
-  endProfiling() {
-    return this.#inferenceSession.endProfiling();
-  }
-}
-
-class PatchedInferenceSession extends ortReactNative.InferenceSession {
-  static #initialized = false;
-
-  static async create(...args) {
-    const { modelPath, modelBytes, options } = normalizeCreateArguments(args);
-    const sessionOptions = sanitizeSessionOptions({
-      ...options,
-      ortExtLibPath: options?.ortExtLibPath ?? Module?.ORT_EXTENSIONS_PATH,
-    });
-
-    if (!PatchedInferenceSession.#initialized) {
-      PatchedInferenceSession.#initialized = true;
-      OrtApi.initOrtOnce(getLogLevelValue(ortReactNative.env.logLevel), ortReactNative.Tensor);
-    }
-
-    const session = OrtApi.createInferenceSession();
-
-    if (typeof modelPath === 'string') {
-      await session.loadModel(modelPath, sessionOptions);
-    } else {
-      await session.loadModel(toExactArrayBuffer(modelBytes), sessionOptions);
-    }
-
-    return new PatchedInferenceSession(new ReactNativeSessionHandler(session));
-  }
-}
-
-module.exports = {
-  ...ortReactNative,
-  InferenceSession: PatchedInferenceSession,
-  Tensor: ortReactNative.Tensor,
-  env: ortReactNative.env,
-  listSupportedBackends: OrtApi.listSupportedBackends ?? ortReactNative.listSupportedBackends,
-};

package/src/expoFileSystemCache.js

@@ -1,251 +0,0 @@
-const { Directory, File, Paths } = require('expo-file-system');
-
-const DEFAULT_MODEL_CACHE_PATH_SEGMENTS = Object.freeze([
-  'automatalabs-react-native-transformers',
-  'models',
-]);
-
-function hashString(value) {
-  let hash = 0x811c9dc5;
-
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 0x01000193);
-  }
-
-  return (hash >>> 0).toString(16).padStart(8, '0');
-}
-
-function sanitizeSegment(value) {
-  const normalized = encodeURIComponent(String(value))
-    .replace(/%/g, '_')
-    .replace(/[^A-Za-z0-9._-]+/g, '_')
-    .replace(/_+/g, '_')
-    .replace(/^_+|_+$/g, '');
-
-  return normalized.slice(0, 120) || 'index';
-}
-
-function getRequestPathSegments(request) {
-  const value = String(request ?? '');
-
-  try {
-    const url = new URL(value);
-    const segments = [sanitizeSegment(url.protocol.replace(/:$/, '')), sanitizeSegment(url.host)];
-    const pathnameSegments = url.pathname.split('/').filter(Boolean).map((segment) => sanitizeSegment(segment));
-
-    segments.push(...pathnameSegments);
-
-    if (segments.length === 2) {
-      segments.push('index');
-    }
-
-    if (url.search) {
-      segments[segments.length - 1] = `${segments[segments.length - 1]}__q_${hashString(url.search)}`;
-    }
-
-    return segments;
-  } catch {
-    const segments = value.split('/').filter(Boolean).map((segment) => sanitizeSegment(segment));
-    return segments.length > 0 ? segments : ['index'];
-  }
-}
-
-function ensureDirectory(directory) {
-  if (!directory.exists) {
-    directory.create({
-      intermediates: true,
-      idempotent: true,
-    });
-  }
-}
-
-function deleteIfExists(file) {
-  if (file?.exists) {
-    try {
-      file.delete();
-    } catch {
-      // ignore cleanup failures
-    }
-  }
-}
-
-function getCachePaths(rootDirectory, request) {
-  const requestPathSegments = getRequestPathSegments(request);
-  const directorySegments = requestPathSegments.slice(0, -1);
-  const leafSegment = requestPathSegments.at(-1) ?? 'index';
-  const requestHash = hashString(String(request ?? ''));
-  const baseName = `${leafSegment}__${requestHash}`;
-  const directory = new Directory(rootDirectory, ...directorySegments);
-
-  return {
-    directory,
-    dataFile: new File(directory, `${baseName}.data`),
-    metadataFile: new File(directory, `${baseName}.meta.json`),
-    tempDataFile: new File(directory, `${baseName}.tmp.data`),
-    tempMetadataFile: new File(directory, `${baseName}.tmp.meta.json`),
-  };
-}
-
-async function readMetadata(metadataFile) {
-  if (!metadataFile.exists) {
-    return null;
-  }
-
-  try {
-    return JSON.parse(await metadataFile.text());
-  } catch {
-    return null;
-  }
-}
-
-function createResponseHeaders(dataFile, metadata) {
-  const headers = new Headers(metadata?.headers ?? {});
-
-  if (!headers.has('content-length')) {
-    headers.set('content-length', String(dataFile.size ?? 0));
-  }
-
-  return headers;
-}
-
-async function writeMetadata(metadataFile, tempMetadataFile, metadata) {
-  deleteIfExists(tempMetadataFile);
-  tempMetadataFile.create({
-    intermediates: true,
-    overwrite: true,
-  });
-  tempMetadataFile.write(JSON.stringify(metadata));
-  deleteIfExists(metadataFile);
-  tempMetadataFile.move(metadataFile);
-}
-
-async function writeResponseToFile(file, response, progressCallback) {
-  deleteIfExists(file);
-  file.create({
-    intermediates: true,
-    overwrite: true,
-  });
-
-  const total = Number.parseInt(response.headers.get('content-length') ?? '0', 10) || 0;
-  let loaded = 0;
-
-  if (response.body?.getReader) {
-    const reader = response.body.getReader();
-    const handle = file.open();
-
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-
-        if (done) {
-          break;
-        }
-
-        if (value && value.length > 0) {
-          handle.writeBytes(value);
-          loaded += value.length;
-          progressCallback?.({
-            progress: total > 0 ? (loaded / total) * 100 : 0,
-            loaded,
-            total,
-          });
-        }
-      }
-    } finally {
-      handle.close();
-    }
-  } else {
-    const bytes = new Uint8Array(await response.arrayBuffer());
-    file.write(bytes);
-    loaded = bytes.length;
-    progressCallback?.({
-      progress: 100,
-      loaded,
-      total: total || loaded,
-    });
-  }
-}
-
-function normalizeCacheRootDirectory(directory) {
-  if (directory instanceof Directory) {
-    return directory;
-  }
-
-  if (typeof directory === 'string') {
-    return new Directory(directory);
-  }
-
-  return new Directory(Paths.cache, ...DEFAULT_MODEL_CACHE_PATH_SEGMENTS);
-}
-
-function getDefaultExpoFileSystemModelCacheDirectory() {
-  return normalizeCacheRootDirectory();
-}
-
-function createExpoFileSystemCache(options = {}) {
-  const rootDirectory = normalizeCacheRootDirectory(options.directory);
-  ensureDirectory(rootDirectory);
-
-  return {
-    async match(request) {
-      const { dataFile, metadataFile } = getCachePaths(rootDirectory, request);
-
-      if (!dataFile.exists) {
-        return undefined;
-      }
-
-      const metadata = await readMetadata(metadataFile);
-      return new Response(dataFile, {
-        headers: createResponseHeaders(dataFile, metadata),
-        status: metadata?.status ?? 200,
-      });
-    },
-
-    async put(request, response, progressCallback = undefined) {
-      const { directory, dataFile, metadataFile, tempDataFile, tempMetadataFile } = getCachePaths(
-        rootDirectory,
-        request,
-      );
-
-      ensureDirectory(directory);
-
-      try {
-        await writeResponseToFile(tempDataFile, response, progressCallback);
-        deleteIfExists(dataFile);
-        tempDataFile.move(dataFile);
-
-        await writeMetadata(metadataFile, tempMetadataFile, {
-          request: String(request ?? ''),
-          status: response.status ?? 200,
-          headers: Object.fromEntries(response.headers.entries()),
-          cachedAt: Date.now(),
-        });
-      } catch (error) {
-        deleteIfExists(tempDataFile);
-        deleteIfExists(tempMetadataFile);
-        throw error;
-      }
-    },
-
-    async delete(request) {
-      const { dataFile, metadataFile } = getCachePaths(rootDirectory, request);
-      const hadData = dataFile.exists;
-      const hadMetadata = metadataFile.exists;
-
-      deleteIfExists(dataFile);
-      deleteIfExists(metadataFile);
-
-      return hadData || hadMetadata;
-    },
-
-    get directory() {
-      return rootDirectory;
-    },
-  };
-}
-
-module.exports = {
-  createExpoFileSystemCache,
-  getDefaultExpoFileSystemModelCacheDirectory,
-};

package/src/index.js

@@ -1,27 +0,0 @@
-const {
-  installTransformersReactNativeGlobals,
-  configureTransformersEnvironment,
-  ensureTransformersFetch,
-  getSupportedExecutionProviderNames,
-  getDefaultExecutionProviders,
-  rewriteExecutionProviders,
-  sanitizeSessionOptions,
-  normalizeTransformersConfig,
-  normalizeTransformersOptions,
-  createExpoFileSystemCache,
-  getDefaultExpoFileSystemModelCacheDirectory,
-} = require('./runtime');
-
-module.exports = {
-  installTransformersReactNativeGlobals,
-  configureTransformersEnvironment,
-  ensureTransformersFetch,
-  getSupportedExecutionProviderNames,
-  getDefaultExecutionProviders,
-  rewriteExecutionProviders,
-  sanitizeSessionOptions,
-  normalizeTransformersConfig,
-  normalizeTransformersOptions,
-  createExpoFileSystemCache,
-  getDefaultExpoFileSystemModelCacheDirectory,
-};

package/src/metro.js

@@ -1,66 +0,0 @@
-const path = require('node:path');
-
-function mergeUnique(existing = [], additions = []) {
-  return Array.from(new Set([...(existing ?? []), ...additions]));
-}
-
-function getTransformersReactNativeAliases(overrides = {}) {
-  const packageRoot = path.resolve(__dirname, '..');
-  const adapterPath = path.join(packageRoot, 'src/adapter/onnxruntime-web-webgpu.js');
-  const wrapperPath = path.join(packageRoot, 'src/transformers.js');
-  const transformersNodeEntryPath = require.resolve('@huggingface/transformers', {
-    paths: [process.cwd(), packageRoot],
-  });
-  const transformersWebEntryPath = path.join(path.dirname(transformersNodeEntryPath), 'transformers.web.js');
-  const onnxruntimePackagePath = require.resolve('onnxruntime-react-native/package.json', {
-    paths: [process.cwd(), packageRoot],
-  });
-  const onnxruntimeCommonPath = require.resolve('onnxruntime-common', {
-    paths: [process.cwd(), path.dirname(onnxruntimePackagePath), packageRoot],
-  });
-
-  return {
-    '@huggingface/transformers': wrapperPath,
-    '@automatalabs/react-native-transformers/internal-transformers-web': transformersWebEntryPath,
-    'onnxruntime-node': adapterPath,
-    'onnxruntime-web': adapterPath,
-    'onnxruntime-web/webgpu': adapterPath,
-    'onnxruntime-common': onnxruntimeCommonPath,
-    ...overrides,
-  };
-}
-
-function withTransformersReactNativeMetro(config, options = {}) {
-  const { aliases: aliasOverrides, watchFolders = [] } = options;
-  const aliases = getTransformersReactNativeAliases(aliasOverrides);
-  const previousResolveRequest = config?.resolver?.resolveRequest;
-
-  return {
-    ...config,
-    watchFolders: mergeUnique(config?.watchFolders, watchFolders),
-    resolver: {
-      ...config.resolver,
-      assetExts: mergeUnique(config?.resolver?.assetExts, ['onnx', 'ort']),
-      resolveRequest(context, moduleName, platform) {
-        const alias =
-          aliases[moduleName] ??
-          (moduleName.startsWith('onnxruntime-web/') ? aliases['onnxruntime-web'] : undefined);
-
-        if (alias) {
-          return context.resolveRequest(context, alias, platform);
-        }
-
-        if (previousResolveRequest) {
-          return previousResolveRequest(context, moduleName, platform);
-        }
-
-        return context.resolveRequest(context, moduleName, platform);
-      },
-    },
-  };
-}
-
-module.exports = {
-  getTransformersReactNativeAliases,
-  withTransformersReactNativeMetro,
-};