@babylonjs/lite-compat 0.0.1-preview.54961

package/bundler-resolve-0pEkTP9X.js

@@ -0,0 +1,33 @@
+function mapBabylonImport(source) {
+  if (/^@babylonjs\/(core|loaders)(\/|$)/.test(source)) {
+    return "core";
+  }
+  if (/^@babylonjs\/addons(\/|$)/.test(source)) {
+    return "addons";
+  }
+  if (/^@recast-navigation\/(core|generators)(\/|$)/.test(source)) {
+    return "recast";
+  }
+  if (/^@babylonjs\/materials(\/|$)/.test(source)) {
+    return "materials";
+  }
+  return null;
+}
+const COMPAT_SPECIFIER = {
+  core: "@babylonjs/lite-compat",
+  addons: "@babylonjs/lite-compat/navigation",
+  recast: "@babylonjs/lite-compat/recast-shim",
+  // `GridMaterial` is re-exported from the root barrel, so the materials
+  // redirect folds into the main entry rather than carrying its own subpath.
+  materials: "@babylonjs/lite-compat"
+};
+function resolveCompatSpecifier(source) {
+  const target = mapBabylonImport(source);
+  return target ? COMPAT_SPECIFIER[target] : null;
+}
+const COMPAT_SOURCE_FILTER = /^@babylonjs\/|^@recast-navigation\//;
+export {
+  COMPAT_SOURCE_FILTER as C,
+  resolveCompatSpecifier as r
+};
+//# sourceMappingURL=bundler-resolve-0pEkTP9X.js.map

package/bundler-resolve-0pEkTP9X.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundler-resolve-0pEkTP9X.js","sources":["../src/bundler-resolve.ts"],"sourcesContent":["/**\n * Shared Babylon.js → `@babylonjs/lite-compat` import-mapping table.\n *\n * This is the single source of truth used by every bundler adapter\n * ([vite.ts](vite.ts), [rollup.ts](rollup.ts), [webpack.ts](webpack.ts),\n * [esbuild.ts](esbuild.ts)) and by the lab's side-by-side dev harness\n * ([../../../lab/vite.config.ts](../../../lab/vite.config.ts)), so the redirect\n * rules can never drift between them. It is a pure, dependency-free mapping,\n * which keeps it trivially unit-testable.\n */\n\n/** The compat module category a Babylon.js import is redirected onto. */\nexport type CompatTarget = \"core\" | \"addons\" | \"recast\" | \"materials\";\n\n/**\n * Map a Babylon.js (or Recast) import specifier onto the compat module category\n * that replaces it, or `null` when the specifier is not remapped.\n *\n * - `@babylonjs/core` / `@babylonjs/loaders` — bare, deep subpaths, and\n *   side-effect-only imports → `\"core\"` (the compat barrel).\n * - `@babylonjs/addons` — bare or any subpath → `\"addons\"` (compat navigation\n *   wrapper over Babylon Lite's native Recast API; navigation is the only addon\n *   currently implemented).\n * - `@recast-navigation/core` / `@recast-navigation/generators` → `\"recast\"`\n *   (no-op shim; Lite loads its own Recast wasm).\n * - `@babylonjs/materials` — bare or any subpath → `\"materials\"` (the compat\n *   barrel, which re-exports `GridMaterial`; grid is the only material currently\n *   implemented).\n */\nexport function mapBabylonImport(source: string): CompatTarget | null {\n    if (/^@babylonjs\\/(core|loaders)(\\/|$)/.test(source)) {\n        return \"core\";\n    }\n    if (/^@babylonjs\\/addons(\\/|$)/.test(source)) {\n        return \"addons\";\n    }\n    if (/^@recast-navigation\\/(core|generators)(\\/|$)/.test(source)) {\n        return \"recast\";\n    }\n    if (/^@babylonjs\\/materials(\\/|$)/.test(source)) {\n        return \"materials\";\n    }\n    return null;\n}\n\n/**\n * Public `@babylonjs/lite-compat` specifier each redirect category resolves to.\n * Returning bare specifiers (rather than absolute paths) defers resolution to\n * the package's own `exports` map, so the adapters work whether the package is\n * consumed from source (this monorepo) or from its published `dist` build, and\n * across every bundler's native resolver.\n */\nconst COMPAT_SPECIFIER: Record<CompatTarget, string> = {\n    core: \"@babylonjs/lite-compat\",\n    addons: \"@babylonjs/lite-compat/navigation\",\n    recast: \"@babylonjs/lite-compat/recast-shim\",\n    // `GridMaterial` is re-exported from the root barrel, so the materials\n    // redirect folds into the main entry rather than carrying its own subpath.\n    materials: \"@babylonjs/lite-compat\",\n};\n\n/**\n * Resolve a Babylon.js (or Recast) import specifier to the bare\n * `@babylonjs/lite-compat` specifier that replaces it, or `null` when the\n * specifier is not remapped. Each bundler adapter feeds the returned specifier\n * back into that bundler's own resolver to obtain the final on-disk module.\n */\nexport function resolveCompatSpecifier(source: string): string | null {\n    const target = mapBabylonImport(source);\n    return target ? COMPAT_SPECIFIER[target] : null;\n}\n\n/**\n * Broad prefix matcher for the specifiers any adapter might remap. Bundlers that\n * filter by `RegExp` (Webpack, esbuild) use this to narrow the hook to plausible\n * candidates; `resolveCompatSpecifier` then makes the precise decision (and\n * returns `null` for non-matches such as `@babylonjs/gui`).\n */\nexport const COMPAT_SOURCE_FILTER = /^@babylonjs\\/|^@recast-navigation\\//;\n"],"names":[],"mappings":"AA6BO,SAAS,iBAAiB,QAAqC;AAClE,MAAI,oCAAoC,KAAK,MAAM,GAAG;AAClD,WAAO;AAAA,EACX;AACA,MAAI,4BAA4B,KAAK,MAAM,GAAG;AAC1C,WAAO;AAAA,EACX;AACA,MAAI,+CAA+C,KAAK,MAAM,GAAG;AAC7D,WAAO;AAAA,EACX;AACA,MAAI,+BAA+B,KAAK,MAAM,GAAG;AAC7C,WAAO;AAAA,EACX;AACA,SAAO;AACX;AASA,MAAM,mBAAiD;AAAA,EACnD,MAAM;AAAA,EACN,QAAQ;AAAA,EACR,QAAQ;AAAA;AAAA;AAAA,EAGR,WAAW;AACf;AAQO,SAAS,uBAAuB,QAA+B;AAClE,QAAM,SAAS,iBAAiB,MAAM;AACtC,SAAO,SAAS,iBAAiB,MAAM,IAAI;AAC/C;AAQO,MAAM,uBAAuB;"}

package/esbuild.d.ts

@@ -0,0 +1,68 @@
+declare interface EsbuildOnResolveResult {
+    path?: string;
+    external?: boolean;
+    namespace?: string;
+    errors?: unknown[];
+}
+
+declare interface EsbuildPlugin {
+    name: string;
+    setup(build: EsbuildPluginBuild): void;
+}
+
+declare interface EsbuildPluginBuild {
+    onResolve(options: {
+        filter: RegExp;
+    }, callback: (args: EsbuildResolveArgs) => Promise<EsbuildOnResolveResult | null>): void;
+    resolve(path: string, options: {
+        importer?: string;
+        namespace?: string;
+        resolveDir?: string;
+        kind: string;
+    }): Promise<EsbuildResolveResult>;
+}
+
+/**
+ * A reusable esbuild plugin that lets an existing Babylon.js project run on
+ * Babylon Lite **without changing its import statements**. It rewrites
+ * `@babylonjs/core`, `@babylonjs/loaders`, `@babylonjs/addons`,
+ * `@babylonjs/materials`, and `@recast-navigation/*` imports
+ * onto the matching `@babylonjs/lite-compat` modules at resolve time.
+ *
+ * Usage (`esbuild` build script):
+ *
+ * ```js
+ * import { build } from "esbuild";
+ * import { liteCompat } from "@babylonjs/lite-compat/esbuild";
+ *
+ * await build({
+ *     plugins: [liteCompat()],
+ * });
+ * ```
+ *
+ * The redirect table is shared with every other adapter via
+ * [bundler-resolve.ts](bundler-resolve.ts).
+ */
+/** Minimal structural types for the slice of the esbuild plugin API used here. */
+declare interface EsbuildResolveArgs {
+    path: string;
+    importer: string;
+    namespace: string;
+    resolveDir: string;
+    kind: string;
+}
+
+declare interface EsbuildResolveResult {
+    path: string;
+    external: boolean;
+    namespace: string;
+    errors: unknown[];
+}
+
+/**
+ * Create the Babylon Lite compat esbuild plugin. Add it to your build's
+ * `plugins` array and keep your Babylon.js imports exactly as they are.
+ */
+export declare function liteCompat(): EsbuildPlugin;
+
+export { }

package/esbuild.js

@@ -0,0 +1,27 @@
+import { C as COMPAT_SOURCE_FILTER, r as resolveCompatSpecifier } from "./bundler-resolve-0pEkTP9X.js";
+function liteCompat() {
+  return {
+    name: "babylonjs-lite-compat",
+    setup(build) {
+      build.onResolve({ filter: COMPAT_SOURCE_FILTER }, async (args) => {
+        const specifier = resolveCompatSpecifier(args.path);
+        if (!specifier) {
+          return null;
+        }
+        const resolved = await build.resolve(specifier, {
+          importer: args.importer,
+          resolveDir: args.resolveDir,
+          kind: args.kind
+        });
+        if (resolved.errors.length > 0) {
+          return { errors: resolved.errors };
+        }
+        return { path: resolved.path, external: resolved.external, namespace: resolved.namespace };
+      });
+    }
+  };
+}
+export {
+  liteCompat
+};
+//# sourceMappingURL=esbuild.js.map

package/esbuild.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild.js","sources":["../src/esbuild.ts"],"sourcesContent":["/**\n * A reusable esbuild plugin that lets an existing Babylon.js project run on\n * Babylon Lite **without changing its import statements**. It rewrites\n * `@babylonjs/core`, `@babylonjs/loaders`, `@babylonjs/addons`,\n * `@babylonjs/materials`, and `@recast-navigation/*` imports\n * onto the matching `@babylonjs/lite-compat` modules at resolve time.\n *\n * Usage (`esbuild` build script):\n *\n * ```js\n * import { build } from \"esbuild\";\n * import { liteCompat } from \"@babylonjs/lite-compat/esbuild\";\n *\n * await build({\n *     plugins: [liteCompat()],\n * });\n * ```\n *\n * The redirect table is shared with every other adapter via\n * [bundler-resolve.ts](bundler-resolve.ts).\n */\n\nimport { resolveCompatSpecifier, COMPAT_SOURCE_FILTER } from \"./bundler-resolve.js\";\n\n/** Minimal structural types for the slice of the esbuild plugin API used here. */\ninterface EsbuildResolveArgs {\n    path: string;\n    importer: string;\n    namespace: string;\n    resolveDir: string;\n    kind: string;\n}\n\ninterface EsbuildResolveResult {\n    path: string;\n    external: boolean;\n    namespace: string;\n    errors: unknown[];\n}\n\ninterface EsbuildOnResolveResult {\n    path?: string;\n    external?: boolean;\n    namespace?: string;\n    errors?: unknown[];\n}\n\ninterface EsbuildPluginBuild {\n    onResolve(options: { filter: RegExp }, callback: (args: EsbuildResolveArgs) => Promise<EsbuildOnResolveResult | null>): void;\n    resolve(path: string, options: { importer?: string; namespace?: string; resolveDir?: string; kind: string }): Promise<EsbuildResolveResult>;\n}\n\ninterface EsbuildPlugin {\n    name: string;\n    setup(build: EsbuildPluginBuild): void;\n}\n\n/**\n * Create the Babylon Lite compat esbuild plugin. Add it to your build's\n * `plugins` array and keep your Babylon.js imports exactly as they are.\n */\nexport function liteCompat(): EsbuildPlugin {\n    return {\n        name: \"babylonjs-lite-compat\",\n        setup(build) {\n            build.onResolve({ filter: COMPAT_SOURCE_FILTER }, async (args) => {\n                const specifier = resolveCompatSpecifier(args.path);\n                if (!specifier) {\n                    // Not a remapped specifier (e.g. `@babylonjs/gui`) — let esbuild\n                    // resolve it normally.\n                    return null;\n                }\n                // Re-run esbuild's own resolver on the compat specifier so the\n                // package's `exports` map (source vs. dist) is honored. The result\n                // does not re-match (`@babylonjs/lite-compat` maps to nothing), so\n                // there is no resolution loop.\n                const resolved = await build.resolve(specifier, {\n                    importer: args.importer,\n                    resolveDir: args.resolveDir,\n                    kind: args.kind,\n                });\n                if (resolved.errors.length > 0) {\n                    return { errors: resolved.errors };\n                }\n                return { path: resolved.path, external: resolved.external, namespace: resolved.namespace };\n            });\n        },\n    };\n}\n"],"names":[],"mappings":";AA6DO,SAAS,aAA4B;AACxC,SAAO;AAAA,IACH,MAAM;AAAA,IACN,MAAM,OAAO;AACT,YAAM,UAAU,EAAE,QAAQ,qBAAA,GAAwB,OAAO,SAAS;AAC9D,cAAM,YAAY,uBAAuB,KAAK,IAAI;AAClD,YAAI,CAAC,WAAW;AAGZ,iBAAO;AAAA,QACX;AAKA,cAAM,WAAW,MAAM,MAAM,QAAQ,WAAW;AAAA,UAC5C,UAAU,KAAK;AAAA,UACf,YAAY,KAAK;AAAA,UACjB,MAAM,KAAK;AAAA,QAAA,CACd;AACD,YAAI,SAAS,OAAO,SAAS,GAAG;AAC5B,iBAAO,EAAE,QAAQ,SAAS,OAAA;AAAA,QAC9B;AACA,eAAO,EAAE,MAAM,SAAS,MAAM,UAAU,SAAS,UAAU,WAAW,SAAS,UAAA;AAAA,MACnF,CAAC;AAAA,IACL;AAAA,EAAA;AAER;"}