@veryfront/ext-bundler-swc 0.1.1252-bootstrap.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,2 @@
+Veryfront Code
+Copyright 2026 Veryfront GmbH

package/README.md

@@ -0,0 +1,101 @@
+# @veryfront/ext-bundler-swc
+
+> **Category:** Build | **Contract:** `Bundler` | **Explicit**
+
+Adds an opt-in SWC TypeScript transform before Veryfront's esbuild graph
+bundler. Use it for libraries that require legacy TypeScript decorator metadata,
+such as class-validator, TypeORM, and constructor-based dependency injection.
+
+The default Veryfront bundler remains esbuild. Projects that do not select this
+extension keep the existing output and standard decorator behavior.
+
+## Install
+
+```bash
+deno add npm:@veryfront/ext-bundler-swc
+```
+
+```bash
+npm install @veryfront/ext-bundler-swc
+```
+
+## Configure
+
+Register the extension explicitly in `veryfront.config.ts`:
+
+```ts
+import { defineConfig } from "veryfront";
+import extSwc from "@veryfront/ext-bundler-swc";
+
+export default defineConfig({
+  extensions: [extSwc()],
+});
+```
+
+Enable both legacy decorator flags in `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  }
+}
+```
+
+Veryfront follows inherited TypeScript configuration. The extension embeds
+`reflect-metadata` before an opted-in decorated module runs, including prepared
+worker modules and compiled runtime routes.
+
+Trusted host execution can follow configuration outside the project directory.
+Isolated preparation accepts parent and package configuration only when it stays
+inside the project boundary, including project-owned `node_modules`. Copy an
+external shared configuration into the project before using it in an isolated
+runtime.
+
+If `experimentalDecorators` is false or absent, the extension delegates source
+unchanged to esbuild when Veryfront already needs a bundle or transform. Local
+Deno routes keep their normal direct-import path. If only
+`experimentalDecorators` is true, SWC emits legacy decorators without runtime
+type metadata.
+
+## What changes when you enable it
+
+`experimentalDecorators: true` switches the TypeScript transform for the whole
+project boundary, not just for decorated files. Every `.ts` and `.tsx` module in
+the build graph is compiled by SWC instead of esbuild, so the emitted JavaScript
+can differ in places that have nothing to do with decorators. Examples include
+enum declaration merging and class-field initialization.
+
+The extension reads only `experimentalDecorators` and
+`emitDecoratorMetadata` from `tsconfig.json`. Veryfront bundle settings still
+control the target and JSX transform. Other TypeScript emit settings, such as
+`useDefineForClassFields`, are not forwarded to SWC.
+
+The legacy SWC path does not compose source maps yet. A bundle or transform
+that enables legacy decorators and requests a source map fails with an
+actionable error instead of returning a map to generated JavaScript. Flags-off
+calls continue to delegate source maps to esbuild.
+
+When legacy decorators are enabled, local Deno API routes use per-route bundles
+so their source passes through SWC. Two route bundles do not share module-level
+state from a common imported project file. Put shared clients, pools, caches,
+and registries behind a framework service or extension instead of relying on a
+cross-route module singleton.
+
+Treat turning the flag on as a transform swap, not as an addition. Re-run your
+test suite after enabling it. Leaving `experimentalDecorators` false or absent
+does not force local routes through bundling and keeps existing bundler calls on
+the esbuild delegate.
+
+## Runtime and packaging
+
+The extension uses `@swc/wasm`, so one package works across Deno, Node.js, Bun,
+and supported compiled binaries. It delegates module resolution, plugins,
+incremental contexts, and final output generation to
+`@veryfront/ext-bundler-esbuild`.
+
+The WASM and reflection runtime stay in this explicit extension package. They
+do not become dependencies of core or the default `veryfront` package. The SWC
+WASM asset is about 20 MB, so distributions and compiled binaries that embed
+the explicit extension must account for that size.

package/esm/_dnt.polyfills.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+import { createRequire } from "node:module";
+import { type URL } from "node:url";
+declare global {
+    interface ImportMeta {
+        /** A string representation of the fully qualified module URL. When the
+         * module is loaded locally, the value will be a file URL (e.g.
+         * `file:///path/module.ts`).
+         *
+         * You can also parse the string as a URL to determine more information about
+         * how the current module was loaded. For example to determine if a module was
+         * local or not:
+         *
+         * ```ts
+         * const url = new URL(import.meta.url);
+         * if (url.protocol === "file:") {
+         *   console.log("this module was loaded locally");
+         * }
+         * ```
+         */
+        url: string;
+        /**
+         * A function that returns resolved specifier as if it would be imported
+         * using `import(specifier)`.
+         *
+         * ```ts
+         * console.log(import.meta.resolve("./foo.js"));
+         * // file:///dev/foo.js
+         * ```
+         *
+         * @param specifier The module specifier to resolve relative to `parent`.
+         * @param parent The absolute parent module URL to resolve from.
+         * @returns The absolute (`file:`) URL string for the resolved module.
+         */
+        resolve(specifier: string, parent?: string | URL | undefined): string;
+        /** A flag that indicates if the current module is the main module that was
+         * called when starting the program under Deno.
+         *
+         * ```ts
+         * if (import.meta.main) {
+         *   // this was loaded as the main module, maybe do some bootstrapping
+         * }
+         * ```
+         */
+        main: boolean;
+        /** The absolute path of the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.filename); // /home/alice/my_module.ts
+         *
+         * // Windows
+         * console.log(import.meta.filename); // C:\alice\my_module.ts
+         * ```
+         */
+        filename: string;
+        /** The absolute path of the directory containing the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.dirname); // /home/alice
+         *
+         * // Windows
+         * console.log(import.meta.dirname); // C:\alice
+         * ```
+         */
+        dirname: string;
+    }
+}
+type NodeRequest = ReturnType<typeof createRequire>;
+type NodeModule = NonNullable<NodeRequest["main"]>;
+interface ImportMetaPonyfillCommonjs {
+    (require: NodeRequest, module: NodeModule): ImportMeta;
+}
+interface ImportMetaPonyfillEsmodule {
+    (importMeta: ImportMeta): ImportMeta;
+}
+interface ImportMetaPonyfill extends ImportMetaPonyfillCommonjs, ImportMetaPonyfillEsmodule {
+}
+export declare let import_meta_ponyfill_commonjs: ImportMetaPonyfillCommonjs;
+export declare let import_meta_ponyfill_esmodule: ImportMetaPonyfillEsmodule;
+export declare let import_meta_ponyfill: ImportMetaPonyfill;
+export {};
+//# sourceMappingURL=_dnt.polyfills.d.ts.map

package/esm/_dnt.polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAAgC,KAAK,GAAG,EAAE,MAAM,UAAU,CAAC;AAGlE,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,UAAU;QAClB;;;;;;;;;;;;;;WAcG;QACH,GAAG,EAAE,MAAM,CAAC;QACZ;;;;;;;;;;;;WAYG;QACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,GAAG,MAAM,CAAC;QACtE;;;;;;;;WAQG;QACH,IAAI,EAAE,OAAO,CAAC;QAEd;;;;;;;;;;;;WAYG;QACH,QAAQ,EAAE,MAAM,CAAC;QAEjB;;;;;;;;;;;;WAYG;QACH,OAAO,EAAE,MAAM,CAAC;KACjB;CACF;AAED,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,KAAK,UAAU,GAAG,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;AACnD,UAAU,0BAA0B;IAClC,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;CACxD;AACD,UAAU,0BAA0B;IAClC,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAAC;CACtC;AACD,UAAU,kBACR,SAAQ,0BAA0B,EAAE,0BAA0B;CAC/D;AAiBD,eAAO,IAAI,6BAA6B,EA2BnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,6BAA6B,EA+DnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,oBAAoB,EAoB1B,kBAAkB,CAAC"}

package/esm/_dnt.polyfills.js

@@ -0,0 +1,130 @@
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+//@ts-ignore
+import { createRequire } from "node:module";
+//@ts-ignore
+import { fileURLToPath, pathToFileURL } from "node:url";
+//@ts-ignore
+import { dirname } from "node:path";
+const defineGlobalPonyfill = (symbolFor, fn) => {
+    if (!Reflect.has(globalThis, Symbol.for(symbolFor))) {
+        Object.defineProperty(globalThis, Symbol.for(symbolFor), {
+            configurable: true,
+            get() {
+                return fn;
+            },
+        });
+    }
+};
+export let import_meta_ponyfill_commonjs = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-commonjs")) ??
+    (() => {
+        const moduleImportMetaWM = new WeakMap();
+        return (require, module) => {
+            let importMetaCache = moduleImportMetaWM.get(module);
+            if (importMetaCache == null) {
+                const importMeta = Object.assign(Object.create(null), {
+                    url: pathToFileURL(module.filename).href,
+                    main: require.main == module,
+                    resolve: (specifier, parentURL = importMeta.url) => {
+                        return pathToFileURL((importMeta.url === parentURL
+                            ? require
+                            : createRequire(parentURL))
+                            .resolve(specifier)).href;
+                    },
+                    filename: module.filename,
+                    dirname: module.path,
+                });
+                moduleImportMetaWM.set(module, importMeta);
+                importMetaCache = importMeta;
+            }
+            return importMetaCache;
+        };
+    })());
+defineGlobalPonyfill("import-meta-ponyfill-commonjs", import_meta_ponyfill_commonjs);
+export let import_meta_ponyfill_esmodule = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-esmodule")) ??
+    ((importMeta) => {
+        const resolveFunStr = String(importMeta.resolve);
+        const shimWs = new WeakSet();
+        //@ts-ignore
+        const mainUrl = ("file:///" + (process.argv[1] ?? "").replace(/\\/g, "/"))
+            .replace(/\/{3,}/, "///");
+        const commonShim = (importMeta) => {
+            if (typeof importMeta.main !== "boolean") {
+                importMeta.main = importMeta.url === mainUrl;
+            }
+            if (typeof importMeta.filename !== "string") {
+                importMeta.filename = fileURLToPath(importMeta.url);
+                importMeta.dirname = dirname(importMeta.filename);
+            }
+        };
+        if (
+        // v16.2.0+, v14.18.0+: Add support for WHATWG URL object to parentURL parameter.
+        resolveFunStr === "undefined" ||
+            // v20.0.0+, v18.19.0+"" This API now returns a string synchronously instead of a Promise.
+            resolveFunStr.startsWith("async")
+        // enable by --experimental-import-meta-resolve flag
+        ) {
+            import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    const importMetaUrlRequire = {
+                        url: importMeta.url,
+                        require: createRequire(importMeta.url),
+                    };
+                    // note: the parameter types must be explicitly annotated because
+                    // `@types/node` also declares `ImportMeta.resolve`, which makes
+                    // the contextual type an overload set that provides no inference
+                    importMeta.resolve = function resolve(specifier, parentURL = importMeta.url) {
+                        return pathToFileURL((importMetaUrlRequire.url === parentURL
+                            ? importMetaUrlRequire.require
+                            : createRequire(parentURL)).resolve(specifier)).href;
+                    };
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        else {
+            /// native support
+            import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        return import_meta_ponyfill_esmodule(importMeta);
+    }));
+defineGlobalPonyfill("import-meta-ponyfill-esmodule", import_meta_ponyfill_esmodule);
+export let import_meta_ponyfill = ((...args) => {
+    const _MODULE = (() => {
+        if (typeof require === "function" && typeof module === "object") {
+            return "commonjs";
+        }
+        else {
+            // eval("typeof import.meta");
+            return "esmodule";
+        }
+    })();
+    if (_MODULE === "commonjs") {
+        //@ts-ignore
+        import_meta_ponyfill = (r, m) => import_meta_ponyfill_commonjs(r, m);
+    }
+    else {
+        //@ts-ignore
+        import_meta_ponyfill = (im) => import_meta_ponyfill_esmodule(im);
+    }
+    //@ts-ignore
+    return import_meta_ponyfill(...args);
+});

package/esm/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Opt-in SWC decorator-metadata transform extension.
+ *
+ * @module extensions/ext-bundler-swc
+ */
+import "./_dnt.polyfills.js";
+import type { ExtensionFactory } from "veryfront/extensions";
+import { SwcBundler } from "./swc-bundler.js";
+declare const extSwc: ExtensionFactory;
+export default extSwc;
+export { SwcBundler };
+//# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,QAAA,MAAM,MAAM,EAAE,gBAcb,CAAC;AAEF,eAAe,MAAM,CAAC;AACtB,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/esm/index.js

@@ -0,0 +1,24 @@
+/**
+ * Opt-in SWC decorator-metadata transform extension.
+ *
+ * @module extensions/ext-bundler-swc
+ */
+import "./_dnt.polyfills.js";
+import { SwcBundler } from "./swc-bundler.js";
+const extSwc = () => {
+    const bundler = new SwcBundler();
+    return {
+        name: "ext-bundler-swc",
+        version: "0.1.0",
+        contracts: { provides: ["Bundler"] },
+        capabilities: [{ type: "fs:read" }],
+        setup(ctx) {
+            ctx.provide("Bundler", bundler);
+        },
+        teardown() {
+            return bundler.stop();
+        },
+    };
+};
+export default extSwc;
+export { SwcBundler };

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/swc-bundler.d.ts

@@ -0,0 +1,18 @@
+import type { BuildContext, BundleOptions, Bundler, BundleResult, TransformOptions, TransformResult, TypeScriptDecoratorOptions } from "veryfront/extensions/bundler";
+/**
+ * SWC-backed legacy TypeScript transform with esbuild graph bundling.
+ *
+ * SWC runs only when `experimentalDecorators` is enabled. All other source is
+ * delegated unchanged, which keeps standard decorators on the default esbuild
+ * behavior even when a project has selected this extension.
+ */
+export declare class SwcBundler implements Bundler {
+    #private;
+    constructor();
+    shouldBundleTypeScript(options: TypeScriptDecoratorOptions): boolean;
+    bundle(options: BundleOptions): Promise<BundleResult>;
+    transform(options: TransformOptions): Promise<TransformResult>;
+    context(options: BundleOptions): Promise<BuildContext>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=swc-bundler.d.ts.map

package/esm/swc-bundler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swc-bundler.d.ts","sourceRoot":"","sources":["../src/swc-bundler.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,OAAO,EACP,YAAY,EAIZ,gBAAgB,EAChB,eAAe,EACf,0BAA0B,EAC3B,MAAM,8BAA8B,CAAC;AA+VtC;;;;;;GAMG;AACH,qBAAa,UAAW,YAAW,OAAO;;;IAOxC,sBAAsB,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO;IAI9D,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAYrD,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IA4B9D,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IActD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

package/esm/swc-bundler.js

@@ -0,0 +1,306 @@
+import { transform as transformWithSwc } from "@swc/wasm";
+import { EsbuildBundler } from "@veryfront/ext-bundler-esbuild";
+import { parseExtensionManifest } from "veryfront/extensions";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { basename, extname, isAbsolute, join, resolve } from "node:path";
+import process from "node:process";
+import { readTypeScriptDecoratorOptions } from "veryfront/extensions/bundler";
+const REFLECT_METADATA_SPECIFIER = "veryfront:swc-reflect-metadata";
+const textDecoder = new TextDecoder();
+const require = createRequire(globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url);
+let reflectMetadataSourcePromise;
+function rawDecoratorOptions(value) {
+    if (typeof value === "string") {
+        value = parseExtensionManifest(value, "jsonc", "tsconfigRaw");
+    }
+    if (value === null || typeof value !== "object")
+        return undefined;
+    const compilerOptionsDescriptor = Reflect.getOwnPropertyDescriptor(value, "compilerOptions");
+    const compilerOptions = compilerOptionsDescriptor?.value;
+    if (compilerOptions === null || typeof compilerOptions !== "object") {
+        return {
+            experimentalDecorators: false,
+            emitDecoratorMetadata: false,
+        };
+    }
+    const experimentalDecorators = Reflect.getOwnPropertyDescriptor(compilerOptions, "experimentalDecorators")?.value;
+    const emitDecoratorMetadata = Reflect.getOwnPropertyDescriptor(compilerOptions, "emitDecoratorMetadata")?.value;
+    return {
+        experimentalDecorators: experimentalDecorators === true,
+        emitDecoratorMetadata: emitDecoratorMetadata === true,
+    };
+}
+function workingDirectory(options) {
+    const explicit = options.absWorkingDir;
+    if (typeof explicit === "string" && explicit.length > 0)
+        return explicit;
+    if ("stdin" in options) {
+        const resolveDir = options.stdin?.resolveDir;
+        if (typeof resolveDir === "string" && resolveDir.length > 0)
+            return resolveDir;
+    }
+    return process.cwd();
+}
+async function decoratorOptions(options) {
+    if ("typescriptDecoratorOptions" in options) {
+        const resolved = rawDecoratorOptions({
+            compilerOptions: options.typescriptDecoratorOptions,
+        });
+        if (resolved)
+            return resolved;
+    }
+    const raw = rawDecoratorOptions(options.tsconfigRaw);
+    if (raw)
+        return raw;
+    const configPath = typeof options.tsconfig === "string"
+        ? isAbsolute(options.tsconfig)
+            ? options.tsconfig
+            : resolve(workingDirectory(options), options.tsconfig)
+        : join(workingDirectory(options), "tsconfig.json");
+    return await readTypeScriptDecoratorOptions({ configPath });
+}
+function isTypeScriptLoader(loader) {
+    return loader === "ts" || loader === "tsx";
+}
+function transformedLoader(loader, options) {
+    return loader === "tsx" && options.jsx === "preserve" ? "jsx" : "js";
+}
+function assertLegacyDecoratorSourceMapsDisabled(options) {
+    if (!options.sourcemap)
+        return;
+    throw new TypeError("The SWC legacy decorator transform does not support source maps. " +
+        "Disable source maps or use the default esbuild transform.");
+}
+function loaderForPath(path) {
+    const extension = extname(path).toLowerCase();
+    if (extension === ".ts" || extension === ".mts" || extension === ".cts")
+        return "ts";
+    if (extension === ".tsx")
+        return "tsx";
+    return undefined;
+}
+function sourceText(contents) {
+    return typeof contents === "string" ? contents : textDecoder.decode(contents);
+}
+function diagnosticFilename(filename) {
+    return basename(filename.replaceAll("\\", "/")) || "source.ts";
+}
+function swcTarget(target) {
+    const value = Array.isArray(target) ? target[0] : target;
+    if (value === "es3" || value === "es5" || value === "es2015" ||
+        value === "es2016" || value === "es2017" || value === "es2018" ||
+        value === "es2019" || value === "es2020" || value === "es2021" ||
+        value === "es2022")
+        return value;
+    return "es2022";
+}
+function reactTransform(options) {
+    const runtime = options.jsx === "preserve"
+        ? "preserve"
+        : options.jsx === "automatic"
+            ? "automatic"
+            : "classic";
+    return {
+        legacyDecorator: true,
+        decoratorMetadata: true,
+        react: {
+            runtime,
+            importSource: options.jsxImportSource,
+        },
+    };
+}
+async function transformTypeScript(code, loader, filename, flags, options) {
+    const transform = reactTransform(options);
+    transform.decoratorMetadata = flags.emitDecoratorMetadata;
+    const moduleType = extname(filename).toLowerCase() === ".cts" ? "commonjs" : "es6";
+    const result = await transformWithSwc(code, {
+        filename: diagnosticFilename(filename),
+        swcrc: false,
+        configFile: false,
+        sourceMaps: false,
+        module: { type: moduleType },
+        jsc: {
+            parser: {
+                syntax: "typescript",
+                tsx: loader === "tsx",
+                decorators: true,
+                dynamicImport: true,
+            },
+            target: swcTarget(options.target),
+            keepClassNames: options.keepNames === true,
+            transform,
+        },
+    });
+    return result.code;
+}
+async function reflectMetadataSource() {
+    reflectMetadataSourcePromise ??= readFile(require.resolve("reflect-metadata/lite"), "utf8");
+    return await reflectMetadataSourcePromise;
+}
+async function withReflectionRuntime(source, flags, options) {
+    if (!flags.emitDecoratorMetadata)
+        return source;
+    if (options.bundle === true) {
+        return `import "${REFLECT_METADATA_SPECIFIER}";\n${source}`;
+    }
+    return `${await reflectMetadataSource()}\n${source}`;
+}
+function wrapPlugin(plugin, flags, options) {
+    return {
+        name: plugin.name,
+        setup(build) {
+            const wrappedBuild = {
+                onResolve: build.onResolve.bind(build),
+                onDispose: build.onDispose.bind(build),
+                onLoad(loadOptions, callback) {
+                    build.onLoad(loadOptions, async (args) => {
+                        const result = await callback(args);
+                        if (!result?.contents)
+                            return result;
+                        // An explicit non-TypeScript loader is the plugin's decision. Only
+                        // infer from the path when the plugin left the loader unset.
+                        const loader = result.loader === undefined
+                            ? loaderForPath(args.path)
+                            : isTypeScriptLoader(result.loader)
+                                ? result.loader
+                                : undefined;
+                        if (!loader)
+                            return result;
+                        return {
+                            ...result,
+                            contents: await withReflectionRuntime(await transformTypeScript(sourceText(result.contents), loader, args.path, flags, options), flags, options),
+                            loader: transformedLoader(loader, options),
+                        };
+                    });
+                },
+            };
+            return plugin.setup(wrappedBuild);
+        },
+    };
+}
+function createReflectMetadataPlugin() {
+    return {
+        name: "veryfront-swc-reflect-metadata",
+        setup(build) {
+            build.onResolve({ filter: /^veryfront:swc-reflect-metadata$/ }, () => ({
+                path: REFLECT_METADATA_SPECIFIER,
+                namespace: "veryfront-swc-reflect-metadata",
+            }));
+            build.onLoad({ filter: /.*/, namespace: "veryfront-swc-reflect-metadata" }, async () => ({ contents: await reflectMetadataSource(), loader: "js" }));
+        },
+    };
+}
+function createSwcFallbackPlugin(flags, options) {
+    return {
+        name: "veryfront-swc-typescript",
+        setup(build) {
+            build.onLoad({ filter: /\.(?:[cm]?ts|tsx)$/ }, async (args) => {
+                const loader = loaderForPath(args.path);
+                if (!loader)
+                    return undefined;
+                options.signal?.throwIfAborted();
+                const code = await readFile(args.path, "utf8");
+                const contents = await withReflectionRuntime(await transformTypeScript(code, loader, args.path, flags, options), flags, options);
+                options.signal?.throwIfAborted();
+                return { contents, loader: transformedLoader(loader, options) };
+            });
+        },
+    };
+}
+function delegateBundleOptions(options) {
+    if (!("typescriptDecoratorOptions" in options))
+        return options;
+    const { typescriptDecoratorOptions: _typescriptDecoratorOptions, ...delegateOptions } = options;
+    return delegateOptions;
+}
+function delegateTransformOptions(options) {
+    if (!("absWorkingDir" in options) &&
+        !("tsconfig" in options) &&
+        !("typescriptDecoratorOptions" in options))
+        return options;
+    const { absWorkingDir: _absWorkingDir, tsconfig: _tsconfig, typescriptDecoratorOptions: _typescriptDecoratorOptions, ...delegateOptions } = options;
+    return delegateOptions;
+}
+async function prepareLegacyDecoratorBundle(options, flags) {
+    const stdin = options.stdin;
+    let transformedStdin = stdin;
+    if (stdin && isTypeScriptLoader(stdin.loader)) {
+        options.signal?.throwIfAborted();
+        const contents = await withReflectionRuntime(await transformTypeScript(stdin.contents, stdin.loader, stdin.sourcefile ?? "stdin.ts", flags, options), flags, options);
+        options.signal?.throwIfAborted();
+        transformedStdin = {
+            ...stdin,
+            contents,
+            loader: transformedLoader(stdin.loader, options),
+        };
+    }
+    const plugins = [
+        createReflectMetadataPlugin(),
+        ...(options.plugins ?? []).map((plugin) => wrapPlugin(plugin, flags, options)),
+        createSwcFallbackPlugin(flags, options),
+    ];
+    return {
+        ...delegateBundleOptions(options),
+        stdin: transformedStdin,
+        plugins,
+    };
+}
+/**
+ * SWC-backed legacy TypeScript transform with esbuild graph bundling.
+ *
+ * SWC runs only when `experimentalDecorators` is enabled. All other source is
+ * delegated unchanged, which keeps standard decorators on the default esbuild
+ * behavior even when a project has selected this extension.
+ */
+export class SwcBundler {
+    #delegate;
+    constructor() {
+        this.#delegate = new EsbuildBundler();
+    }
+    shouldBundleTypeScript(options) {
+        return options.experimentalDecorators;
+    }
+    async bundle(options) {
+        const flags = await decoratorOptions(options);
+        if (!flags.experimentalDecorators) {
+            return await this.#delegate.bundle(delegateBundleOptions(options));
+        }
+        assertLegacyDecoratorSourceMapsDisabled(options);
+        return await this.#delegate.bundle(await prepareLegacyDecoratorBundle(options, flags));
+    }
+    async transform(options) {
+        if (!isTypeScriptLoader(options.loader)) {
+            return await this.#delegate.transform(delegateTransformOptions(options));
+        }
+        const flags = await decoratorOptions(options);
+        if (!flags.experimentalDecorators) {
+            return await this.#delegate.transform(delegateTransformOptions(options));
+        }
+        assertLegacyDecoratorSourceMapsDisabled(options);
+        let code = await transformTypeScript(options.code, options.loader, typeof options.sourcefile === "string" ? options.sourcefile : "stdin.ts", flags, options);
+        if (flags.emitDecoratorMetadata) {
+            code = `${await reflectMetadataSource()}\n${code}`;
+        }
+        const delegateOptions = delegateTransformOptions(options);
+        return await this.#delegate.transform({
+            ...delegateOptions,
+            code,
+            loader: transformedLoader(options.loader, options),
+        });
+    }
+    async context(options) {
+        if (!this.#delegate.context) {
+            throw new Error("The SWC bundler delegate does not support incremental builds");
+        }
+        const flags = await decoratorOptions(options);
+        if (!flags.experimentalDecorators) {
+            return await this.#delegate.context(delegateBundleOptions(options));
+        }
+        assertLegacyDecoratorSourceMapsDisabled(options);
+        return await this.#delegate.context(await prepareLegacyDecoratorBundle(options, flags));
+    }
+    async stop() {
+        await this.#delegate.stop?.();
+    }
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@veryfront/ext-bundler-swc",
+  "version": "0.1.1252-bootstrap.0",
+  "description": "Veryfront first-party extension package for ext-bundler-swc",
+  "keywords": [
+    "veryfront",
+    "extension",
+    "ext-bundler-swc"
+  ],
+  "author": "Veryfront",
+  "homepage": "https://github.com/veryfront/veryfront-code/tree/main/extensions/ext-bundler-swc",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/veryfront/veryfront-code.git",
+    "directory": "extensions/ext-bundler-swc"
+  },
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/veryfront/veryfront-code/issues"
+  },
+  "module": "./esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "types": "./esm/index.d.ts"
+    }
+  },
+  "scripts": {},
+  "engines": {
+    "node": ">=22.3.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "veryfront": {
+    "extension": true,
+    "activation": "explicit",
+    "contracts": {
+      "provides": [
+        "Bundler"
+      ]
+    },
+    "capabilities": [
+      {
+        "type": "fs:read"
+      }
+    ]
+  },
+  "dependencies": {
+    "@swc/wasm": "1.16.1",
+    "@veryfront/ext-bundler-esbuild": "0.1.1252-rc",
+    "reflect-metadata": "0.2.2"
+  },
+  "peerDependencies": {
+    "veryfront": "^0.1.1252-rc"
+  },
+  "type": "module",
+  "types": "./esm/index.d.ts",
+  "files": [
+    "esm",
+    "LICENSE",
+    "NOTICE",
+    "README.md"
+  ]
+}