@ecrindigital/facetpack 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Ecrin Digital
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,141 @@
+# facetpack
+
+[![npm version](https://img.shields.io/npm/v/facetpack.svg)](https://www.npmjs.com/package/facetpack)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+> High-performance Metro transformer powered by [OXC](https://oxc.rs) and Rust.
+
+Replace Babel with a blazing-fast native transformer in your React Native project.
+
+Built by [Ecrin Digital](https://ecrin.digital).
+
+## Features
+
+- **10-50x Faster** - Native Rust transformer powered by OXC
+- **Drop-in Replacement** - Just wrap your Metro config
+- **TypeScript Support** - Full TypeScript parsing and type stripping
+- **JSX/TSX Support** - Automatic and classic runtime support
+- **Source Maps** - Full source map support for debugging
+- **Zero Config** - Works out of the box with sensible defaults
+
+## Installation
+
+```bash
+npm install facetpack facetpack-native
+# or
+yarn add facetpack facetpack-native
+# or
+pnpm add facetpack facetpack-native
+```
+
+## Usage
+
+Wrap your Metro configuration with `withFacetpack`:
+
+```javascript
+// metro.config.js
+const { getDefaultConfig } = require('@react-native/metro-config');
+const { withFacetpack } = require('facetpack');
+
+const config = getDefaultConfig(__dirname);
+
+module.exports = withFacetpack(config);
+```
+
+### With Options
+
+```javascript
+// metro.config.js
+const { getDefaultConfig } = require('@react-native/metro-config');
+const { withFacetpack } = require('facetpack');
+
+const config = getDefaultConfig(__dirname);
+
+module.exports = withFacetpack(config, {
+  // JSX runtime: 'automatic' (default) or 'classic'
+  jsxRuntime: 'automatic',
+
+  // Import source for automatic runtime
+  jsxImportSource: 'react',
+
+  // Enable TypeScript transformation (default: true)
+  typescript: true,
+
+  // Enable JSX transformation (default: true)
+  jsx: true,
+});
+```
+
+### With Expo
+
+```javascript
+// metro.config.js
+const { getDefaultConfig } = require('expo/metro-config');
+const { withFacetpack } = require('facetpack');
+
+const config = getDefaultConfig(__dirname);
+
+module.exports = withFacetpack(config);
+```
+
+## API
+
+### `withFacetpack(config, options?)`
+
+Wraps a Metro configuration with the Facetpack transformer.
+
+#### Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `config` | `MetroConfig` | Your Metro configuration object |
+| `options` | `FacetpackOptions` | Optional configuration options |
+
+#### Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `jsx` | `boolean` | `true` | Enable JSX transformation |
+| `jsxRuntime` | `'automatic' \| 'classic'` | `'automatic'` | JSX runtime mode |
+| `jsxImportSource` | `string` | `'react'` | Import source for automatic runtime |
+| `jsxPragma` | `string` | `'React.createElement'` | Pragma for classic runtime |
+| `jsxPragmaFrag` | `string` | `'React.Fragment'` | Fragment pragma for classic runtime |
+| `typescript` | `boolean` | `true` | Strip TypeScript types |
+| `sourceExts` | `string[]` | `['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs']` | File extensions to transform |
+
+## How It Works
+
+Facetpack replaces Metro's default Babel transformer with a native Rust transformer powered by [OXC](https://oxc.rs). This provides significant performance improvements:
+
+| Operation | vs Babel |
+|-----------|----------|
+| Parse     | ~50x faster |
+| Transform | ~20x faster |
+
+The transformer handles:
+- TypeScript → JavaScript (type stripping)
+- JSX → JavaScript (createElement or jsx-runtime)
+- Source map generation
+
+## Requirements
+
+- React Native 0.73+
+- Metro 0.80+
+- Node.js 18+
+
+## Compatibility
+
+Facetpack is designed to be a drop-in replacement for Babel in most React Native projects. However, if you rely on specific Babel plugins or transforms, you may need to keep Babel for those files.
+
+## License
+
+MIT - see [LICENSE](./LICENSE) for details.
+
+## Credits
+
+- [OXC](https://oxc.rs) - The high-performance JavaScript toolchain
+- [NAPI-RS](https://napi.rs) - Rust bindings for Node.js
+
+---
+
+Made with Rust by [Ecrin Digital](https://ecrin.digital)

package/dist/cache.d.ts

@@ -0,0 +1,8 @@
+export declare function setCachedResolutions(originModulePath: string, resolutions: Map<string, string | null>): void;
+export declare function getCachedResolution(originModulePath: string, specifier: string): string | null | undefined;
+export declare function clearCache(): void;
+export declare function getCacheStats(): {
+    files: number;
+    resolutions: number;
+};
+//# sourceMappingURL=cache.d.ts.map

package/dist/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AASA,wBAAgB,oBAAoB,CAClC,gBAAgB,EAAE,MAAM,EACxB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,GACtC,IAAI,CASN;AAED,wBAAgB,mBAAmB,CACjC,gBAAgB,EAAE,MAAM,EACxB,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,IAAI,GAAG,SAAS,CAa3B;AAED,wBAAgB,UAAU,IAAI,IAAI,CAEjC;AAED,wBAAgB,aAAa,IAAI;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAMtE"}

package/dist/index.cjs

@@ -0,0 +1,330 @@
+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/index.ts
+var exports_src = {};
+__export(exports_src, {
+  withFacetpack: () => withFacetpack,
+  transform: () => transform,
+  setTransformerOptions: () => setTransformerOptions,
+  resolveSync: () => import_facetpack_native3.resolveSync,
+  getStoredOptions: () => getStoredOptions,
+  getCacheStats: () => getCacheStats,
+  createTransformer: () => createTransformer,
+  createResolver: () => createResolver,
+  clearCache: () => clearCache
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/withFacetpack.ts
+var import_facetpack_native = require("@ecrindigital/facetpack-native");
+
+// 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/withFacetpack.ts
+var import_path = require("path");
+var import_url = require("url");
+var DEFAULT_SOURCE_EXTS = ["ts", "tsx", "js", "jsx", "mjs", "cjs"];
+var __filename2 = import_url.fileURLToPath("file:///Users/alexischangridel/Projects/ecrindigital/facetpack/packages/facetpack/src/withFacetpack.ts");
+var __dirname2 = import_path.dirname(__filename2);
+function withFacetpack(config, options = {}) {
+  const sourceExts = options.sourceExts ?? DEFAULT_SOURCE_EXTS;
+  const transformerPath = import_path.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 = import_facetpack_native.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/transformer.ts
+var import_facetpack_native2 = require("@ecrindigital/facetpack-native");
+var import_parser = require("@babel/parser");
+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_native2.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_native2.transformSync(filename, src, {
+      jsx: opts.jsx,
+      jsxRuntime: isClassic ? import_facetpack_native2.JsxRuntime.Classic : import_facetpack_native2.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_native2.transformSync(filename, src, {
+        jsx: opts.jsx,
+        jsxRuntime: isClassic ? import_facetpack_native2.JsxRuntime.Classic : import_facetpack_native2.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/resolver.ts
+var import_facetpack_native3 = require("@ecrindigital/facetpack-native");
+function createResolver(options) {
+  return {
+    resolve(originModulePath, moduleName) {
+      const directory = originModulePath.substring(0, originModulePath.lastIndexOf("/"));
+      const result = import_facetpack_native3.resolveSync(directory, moduleName, options);
+      return result.path ?? null;
+    }
+  };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { withFacetpack, getStoredOptions } from './withFacetpack';
+export { transform, createTransformer, setTransformerOptions } from './transformer';
+export { createResolver, resolveSync } from './resolver';
+export { clearCache, getCacheStats } from './cache';
+export type { FacetpackOptions, MetroConfig, TransformParams, TransformOptions, TransformResult, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACjE,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AACnF,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACxD,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AACnD,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,eAAe,GAChB,MAAM,SAAS,CAAA"}