@ecrindigital/facetpack 0.1.1

package/dist/index.js

@@ -0,0 +1,302 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/transformer.ts
+import { transformSync, JsxRuntime, resolveBatchSync } from "@ecrindigital/facetpack-native";
+import { parse } from "@babel/parser";
+
+// src/cache.ts
+var resolutionCache = new Map;
+var CACHE_TTL = 30000;
+function setCachedResolutions(originModulePath, resolutions) {
+  const now = Date.now();
+  const cached = new Map;
+  for (const [specifier, path] of resolutions) {
+    cached.set(specifier, { path, timestamp: now });
+  }
+  resolutionCache.set(originModulePath, cached);
+}
+function getCachedResolution(originModulePath, specifier) {
+  const fileCache = resolutionCache.get(originModulePath);
+  if (!fileCache)
+    return;
+  const cached = fileCache.get(specifier);
+  if (!cached)
+    return;
+  if (Date.now() - cached.timestamp > CACHE_TTL) {
+    fileCache.delete(specifier);
+    return;
+  }
+  return cached.path;
+}
+function clearCache() {
+  resolutionCache.clear();
+}
+function getCacheStats() {
+  let resolutions = 0;
+  for (const fileCache of resolutionCache.values()) {
+    resolutions += fileCache.size;
+  }
+  return { files: resolutionCache.size, resolutions };
+}
+
+// src/transformer.ts
+var IMPORT_REGEX = /(?:import|export)\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
+var REQUIRE_REGEX = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+function extractSpecifiers(code) {
+  const specifiers = new Set;
+  let match;
+  while ((match = IMPORT_REGEX.exec(code)) !== null) {
+    if (match[1])
+      specifiers.add(match[1]);
+  }
+  while ((match = REQUIRE_REGEX.exec(code)) !== null) {
+    if (match[1])
+      specifiers.add(match[1]);
+  }
+  return Array.from(specifiers);
+}
+function preResolveImports(filename, code, sourceExts) {
+  const specifiers = extractSpecifiers(code);
+  if (specifiers.length === 0)
+    return;
+  const directory = filename.substring(0, filename.lastIndexOf("/"));
+  const results = resolveBatchSync(directory, specifiers, {
+    extensions: [...sourceExts.map((ext) => `.${ext}`), ".json"],
+    mainFields: ["react-native", "browser", "main"],
+    conditionNames: ["react-native", "import", "require"]
+  });
+  const resolutions = new Map;
+  for (let i = 0;i < specifiers.length; i++) {
+    const specifier = specifiers[i];
+    if (specifier) {
+      resolutions.set(specifier, results[i]?.path ?? null);
+    }
+  }
+  setCachedResolutions(filename, resolutions);
+}
+var defaultOptions = {
+  jsx: true,
+  jsxRuntime: "automatic",
+  jsxImportSource: "react",
+  jsxPragma: "React.createElement",
+  jsxPragmaFrag: "React.Fragment",
+  typescript: true,
+  sourceExts: ["ts", "tsx", "js", "jsx", "mjs", "cjs"]
+};
+var globalOptions = {};
+var fallbackTransformer = null;
+function getFallbackTransformer() {
+  if (fallbackTransformer) {
+    return fallbackTransformer;
+  }
+  const transformerPaths = [
+    "@expo/metro-config/babel-transformer",
+    "@react-native/metro-babel-transformer",
+    "metro-react-native-babel-transformer"
+  ];
+  for (const transformerPath of transformerPaths) {
+    try {
+      fallbackTransformer = __require(transformerPath);
+      return fallbackTransformer;
+    } catch {}
+  }
+  fallbackTransformer = {
+    transform: ({ src }) => ({ code: src, map: null })
+  };
+  return fallbackTransformer;
+}
+function setTransformerOptions(options) {
+  globalOptions = options;
+}
+function getOptions() {
+  return { ...defaultOptions, ...globalOptions };
+}
+function isNodeModules(filename) {
+  return filename.includes("node_modules");
+}
+function shouldTransform(filename, options) {
+  if (isNodeModules(filename)) {
+    return false;
+  }
+  const ext = filename.split(".").pop()?.toLowerCase();
+  if (!ext)
+    return false;
+  return options.sourceExts.includes(ext);
+}
+function transform(params) {
+  const { filename, src, options: metroOptions } = params;
+  const opts = getOptions();
+  if (process.env.FACETPACK_DEBUG) {
+    console.log(`[Facetpack] Processing: ${filename}`);
+  }
+  if (!shouldTransform(filename, opts)) {
+    if (process.env.FACETPACK_DEBUG) {
+      console.log(`[Facetpack] Fallback: ${filename}`);
+    }
+    return getFallbackTransformer().transform(params);
+  }
+  if (process.env.FACETPACK_DEBUG) {
+    console.log(`[Facetpack] OXC Transform: ${filename}`);
+  }
+  try {
+    const isClassic = opts.jsxRuntime === "classic";
+    const result = transformSync(filename, src, {
+      jsx: opts.jsx,
+      jsxRuntime: isClassic ? JsxRuntime.Classic : JsxRuntime.Automatic,
+      ...isClassic ? { jsxPragma: opts.jsxPragma, jsxPragmaFrag: opts.jsxPragmaFrag } : { jsxImportSource: opts.jsxImportSource },
+      typescript: opts.typescript,
+      sourcemap: metroOptions.dev
+    });
+    if (result.errors.length > 0) {
+      const errorMessage = result.errors.join(`
+`);
+      throw new Error(`Facetpack transform error in ${filename}:
+${errorMessage}`);
+    }
+    preResolveImports(filename, result.code, opts.sourceExts);
+    const ast = parse(result.code, {
+      sourceType: "unambiguous",
+      plugins: ["jsx"]
+    });
+    const output = {
+      ast,
+      code: result.code,
+      map: result.map ? JSON.parse(result.map) : null
+    };
+    if (process.env.FACETPACK_DEBUG) {
+      console.log(`[Facetpack] Output for ${filename}:`);
+      console.log(result.code.slice(0, 500));
+    }
+    return output;
+  } catch (error) {
+    if (error instanceof Error) {
+      error.message = `[Facetpack] ${error.message}`;
+    }
+    throw error;
+  }
+}
+function createTransformer(options = {}) {
+  const opts = { ...defaultOptions, ...options };
+  return {
+    transform(params) {
+      const { filename, src, options: metroOptions } = params;
+      if (!shouldTransform(filename, opts)) {
+        return getFallbackTransformer().transform(params);
+      }
+      const isClassic = opts.jsxRuntime === "classic";
+      const result = transformSync(filename, src, {
+        jsx: opts.jsx,
+        jsxRuntime: isClassic ? JsxRuntime.Classic : JsxRuntime.Automatic,
+        ...isClassic ? { jsxPragma: opts.jsxPragma, jsxPragmaFrag: opts.jsxPragmaFrag } : { jsxImportSource: opts.jsxImportSource },
+        typescript: opts.typescript,
+        sourcemap: metroOptions.dev
+      });
+      if (result.errors.length > 0) {
+        throw new Error(`Facetpack transform error in ${filename}:
+${result.errors.join(`
+`)}`);
+      }
+      return {
+        code: result.code,
+        map: result.map ? JSON.parse(result.map) : null
+      };
+    }
+  };
+}
+
+// src/withFacetpack.ts
+import { resolveSync } from "@ecrindigital/facetpack-native";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_SOURCE_EXTS = ["ts", "tsx", "js", "jsx", "mjs", "cjs"];
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+function withFacetpack(config, options = {}) {
+  const sourceExts = options.sourceExts ?? DEFAULT_SOURCE_EXTS;
+  const transformerPath = join(__dirname2, "transformer.js");
+  storeTransformerOptions(options);
+  return {
+    ...config,
+    transformer: {
+      ...config.transformer,
+      babelTransformerPath: transformerPath,
+      getTransformOptions: async (entryPoints, opts, getDepsOf) => {
+        const baseOptions = await config.transformer?.getTransformOptions?.(entryPoints, opts, getDepsOf);
+        return {
+          ...baseOptions,
+          transform: {
+            ...baseOptions?.transform,
+            experimentalImportSupport: true,
+            inlineRequires: true
+          }
+        };
+      }
+    },
+    resolver: {
+      ...config.resolver,
+      sourceExts: [
+        ...new Set([
+          ...config.resolver?.sourceExts ?? [],
+          ...sourceExts
+        ])
+      ],
+      resolveRequest: (context, moduleName, platform) => {
+        if (context.originModulePath.includes("node_modules")) {
+          return context.resolveRequest(context, moduleName, platform);
+        }
+        const cached = getCachedResolution(context.originModulePath, moduleName);
+        if (cached !== undefined) {
+          if (cached) {
+            return { type: "sourceFile", filePath: cached };
+          }
+          return context.resolveRequest(context, moduleName, platform);
+        }
+        const directory = context.originModulePath.substring(0, context.originModulePath.lastIndexOf("/"));
+        const result = resolveSync(directory, moduleName, {
+          extensions: [...sourceExts.map((ext) => `.${ext}`), ".json"],
+          mainFields: ["react-native", "browser", "main"],
+          conditionNames: ["react-native", "import", "require"]
+        });
+        if (result.path) {
+          return { type: "sourceFile", filePath: result.path };
+        }
+        return context.resolveRequest(context, moduleName, platform);
+      }
+    }
+  };
+}
+function storeTransformerOptions(options) {
+  process.env.FACETPACK_OPTIONS = JSON.stringify(options);
+}
+function getStoredOptions() {
+  try {
+    const optionsJson = process.env.FACETPACK_OPTIONS;
+    if (optionsJson) {
+      return JSON.parse(optionsJson);
+    }
+  } catch {}
+  return {};
+}
+// src/resolver.ts
+import { resolveSync as resolveSync2 } from "@ecrindigital/facetpack-native";
+function createResolver(options) {
+  return {
+    resolve(originModulePath, moduleName) {
+      const directory = originModulePath.substring(0, originModulePath.lastIndexOf("/"));
+      const result = resolveSync2(directory, moduleName, options);
+      return result.path ?? null;
+    }
+  };
+}
+export {
+  withFacetpack,
+  transform,
+  setTransformerOptions,
+  resolveSync2 as resolveSync,
+  getStoredOptions,
+  getCacheStats,
+  createTransformer,
+  createResolver,
+  clearCache
+};

package/dist/resolver.d.ts

@@ -0,0 +1,6 @@
+import { resolveSync, type ResolverOptions } from '@ecrindigital/facetpack-native';
+export { resolveSync, type ResolverOptions };
+export declare function createResolver(options?: ResolverOptions): {
+    resolve(originModulePath: string, moduleName: string): string | null;
+};
+//# sourceMappingURL=resolver.d.ts.map

package/dist/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../src/resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,KAAK,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAElF,OAAO,EAAE,WAAW,EAAE,KAAK,eAAe,EAAE,CAAA;AAE5C,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,eAAe;8BAE1B,MAAM,cAAc,MAAM,GAAG,MAAM,GAAG,IAAI;EAMvE"}

package/dist/transformer.cjs

@@ -0,0 +1,214 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/transformer.ts
+var exports_transformer = {};
+__export(exports_transformer, {
+  transform: () => transform,
+  setTransformerOptions: () => setTransformerOptions,
+  createTransformer: () => createTransformer
+});
+module.exports = __toCommonJS(exports_transformer);
+var import_facetpack_native = require("@ecrindigital/facetpack-native");
+var import_parser = require("@babel/parser");
+
+// src/cache.ts
+var resolutionCache = new Map;
+function setCachedResolutions(originModulePath, resolutions) {
+  const now = Date.now();
+  const cached = new Map;
+  for (const [specifier, path] of resolutions) {
+    cached.set(specifier, { path, timestamp: now });
+  }
+  resolutionCache.set(originModulePath, cached);
+}
+
+// src/transformer.ts
+var IMPORT_REGEX = /(?:import|export)\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
+var REQUIRE_REGEX = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+function extractSpecifiers(code) {
+  const specifiers = new Set;
+  let match;
+  while ((match = IMPORT_REGEX.exec(code)) !== null) {
+    if (match[1])
+      specifiers.add(match[1]);
+  }
+  while ((match = REQUIRE_REGEX.exec(code)) !== null) {
+    if (match[1])
+      specifiers.add(match[1]);
+  }
+  return Array.from(specifiers);
+}
+function preResolveImports(filename, code, sourceExts) {
+  const specifiers = extractSpecifiers(code);
+  if (specifiers.length === 0)
+    return;
+  const directory = filename.substring(0, filename.lastIndexOf("/"));
+  const results = import_facetpack_native.resolveBatchSync(directory, specifiers, {
+    extensions: [...sourceExts.map((ext) => `.${ext}`), ".json"],
+    mainFields: ["react-native", "browser", "main"],
+    conditionNames: ["react-native", "import", "require"]
+  });
+  const resolutions = new Map;
+  for (let i = 0;i < specifiers.length; i++) {
+    const specifier = specifiers[i];
+    if (specifier) {
+      resolutions.set(specifier, results[i]?.path ?? null);
+    }
+  }
+  setCachedResolutions(filename, resolutions);
+}
+var defaultOptions = {
+  jsx: true,
+  jsxRuntime: "automatic",
+  jsxImportSource: "react",
+  jsxPragma: "React.createElement",
+  jsxPragmaFrag: "React.Fragment",
+  typescript: true,
+  sourceExts: ["ts", "tsx", "js", "jsx", "mjs", "cjs"]
+};
+var globalOptions = {};
+var fallbackTransformer = null;
+function getFallbackTransformer() {
+  if (fallbackTransformer) {
+    return fallbackTransformer;
+  }
+  const transformerPaths = [
+    "@expo/metro-config/babel-transformer",
+    "@react-native/metro-babel-transformer",
+    "metro-react-native-babel-transformer"
+  ];
+  for (const transformerPath of transformerPaths) {
+    try {
+      fallbackTransformer = require(transformerPath);
+      return fallbackTransformer;
+    } catch {}
+  }
+  fallbackTransformer = {
+    transform: ({ src }) => ({ code: src, map: null })
+  };
+  return fallbackTransformer;
+}
+function setTransformerOptions(options) {
+  globalOptions = options;
+}
+function getOptions() {
+  return { ...defaultOptions, ...globalOptions };
+}
+function isNodeModules(filename) {
+  return filename.includes("node_modules");
+}
+function shouldTransform(filename, options) {
+  if (isNodeModules(filename)) {
+    return false;
+  }
+  const ext = filename.split(".").pop()?.toLowerCase();
+  if (!ext)
+    return false;
+  return options.sourceExts.includes(ext);
+}
+function transform(params) {
+  const { filename, src, options: metroOptions } = params;
+  const opts = getOptions();
+  if (process.env.FACETPACK_DEBUG) {
+    console.log(`[Facetpack] Processing: ${filename}`);
+  }
+  if (!shouldTransform(filename, opts)) {
+    if (process.env.FACETPACK_DEBUG) {
+      console.log(`[Facetpack] Fallback: ${filename}`);
+    }
+    return getFallbackTransformer().transform(params);
+  }
+  if (process.env.FACETPACK_DEBUG) {
+    console.log(`[Facetpack] OXC Transform: ${filename}`);
+  }
+  try {
+    const isClassic = opts.jsxRuntime === "classic";
+    const result = import_facetpack_native.transformSync(filename, src, {
+      jsx: opts.jsx,
+      jsxRuntime: isClassic ? import_facetpack_native.JsxRuntime.Classic : import_facetpack_native.JsxRuntime.Automatic,
+      ...isClassic ? { jsxPragma: opts.jsxPragma, jsxPragmaFrag: opts.jsxPragmaFrag } : { jsxImportSource: opts.jsxImportSource },
+      typescript: opts.typescript,
+      sourcemap: metroOptions.dev
+    });
+    if (result.errors.length > 0) {
+      const errorMessage = result.errors.join(`
+`);
+      throw new Error(`Facetpack transform error in ${filename}:
+${errorMessage}`);
+    }
+    preResolveImports(filename, result.code, opts.sourceExts);
+    const ast = import_parser.parse(result.code, {
+      sourceType: "unambiguous",
+      plugins: ["jsx"]
+    });
+    const output = {
+      ast,
+      code: result.code,
+      map: result.map ? JSON.parse(result.map) : null
+    };
+    if (process.env.FACETPACK_DEBUG) {
+      console.log(`[Facetpack] Output for ${filename}:`);
+      console.log(result.code.slice(0, 500));
+    }
+    return output;
+  } catch (error) {
+    if (error instanceof Error) {
+      error.message = `[Facetpack] ${error.message}`;
+    }
+    throw error;
+  }
+}
+function createTransformer(options = {}) {
+  const opts = { ...defaultOptions, ...options };
+  return {
+    transform(params) {
+      const { filename, src, options: metroOptions } = params;
+      if (!shouldTransform(filename, opts)) {
+        return getFallbackTransformer().transform(params);
+      }
+      const isClassic = opts.jsxRuntime === "classic";
+      const result = import_facetpack_native.transformSync(filename, src, {
+        jsx: opts.jsx,
+        jsxRuntime: isClassic ? import_facetpack_native.JsxRuntime.Classic : import_facetpack_native.JsxRuntime.Automatic,
+        ...isClassic ? { jsxPragma: opts.jsxPragma, jsxPragmaFrag: opts.jsxPragmaFrag } : { jsxImportSource: opts.jsxImportSource },
+        typescript: opts.typescript,
+        sourcemap: metroOptions.dev
+      });
+      if (result.errors.length > 0) {
+        throw new Error(`Facetpack transform error in ${filename}:
+${result.errors.join(`
+`)}`);
+      }
+      return {
+        code: result.code,
+        map: result.map ? JSON.parse(result.map) : null
+      };
+    }
+  };
+}

package/dist/transformer.d.ts

@@ -0,0 +1,7 @@
+import type { TransformParams, TransformResult, FacetpackOptions } from './types';
+export declare function setTransformerOptions(options: FacetpackOptions): void;
+export declare function transform(params: TransformParams): TransformResult;
+export declare function createTransformer(options?: FacetpackOptions): {
+    transform(params: TransformParams): TransformResult;
+};
+//# sourceMappingURL=transformer.d.ts.map

package/dist/transformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../src/transformer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAwFjF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAErE;AAoBD,wBAAgB,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,CA6DlE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,gBAAqB;sBAI1C,eAAe,GAAG,eAAe;EA4BtD"}