@swc/core 1.5.23 → 1.5.25

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@swc/core",
-  "version": "1.5.23",
+  "version": "1.5.25",
   "description": "Super-fast alternative for babel",
   "homepage": "https://swc.rs",
-  "main": "./src/index.js",
+  "main": "./index.js",
   "author": "강동윤 <kdy1997.dev@gmail.com>",
   "license": "Apache-2.0",
   "keywords": [
@@ -44,7 +44,7 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "types": "./src/index.d.ts",
+  "types": "./index.d.ts",
   "scripts": {
     "postinstall": "node postinstall.js",
     "artifacts": "napi artifacts --npm-dir scripts/npm",
@@ -71,21 +71,21 @@
   },
   "files": [
     "CHANGELOG.md",
-    "src/Visitor.d.ts",
-    "src/index.d.ts",
-    "src/spack.js",
-    "src/util.d.ts",
+    "Visitor.d.ts",
+    "index.d.ts",
+    "spack.js",
+    "util.d.ts",
     "LICENSE",
-    "src/Visitor.js",
-    "src/binding.d.ts",
-    "src/index.js",
-    "src/types.d.ts",
-    "src/util.js",
+    "Visitor.js",
+    "binding.d.ts",
+    "index.js",
+    "types.d.ts",
+    "util.js",
     "README.md",
     "binding.js",
     "package.json",
-    "src/spack.d.ts",
-    "src/types.js",
+    "spack.d.ts",
+    "types.js",
     "postinstall.js",
     "bindings/binding_core_wasm/pkg/binding_core_wasm.d.ts"
   ],
@@ -100,15 +100,15 @@
     "typescript": "^5.3.3"
   },
   "optionalDependencies": {
-    "@swc/core-darwin-x64": "1.5.23",
-    "@swc/core-win32-x64-msvc": "1.5.23",
-    "@swc/core-linux-x64-gnu": "1.5.23",
-    "@swc/core-linux-x64-musl": "1.5.23",
-    "@swc/core-win32-ia32-msvc": "1.5.23",
-    "@swc/core-linux-arm-gnueabihf": "1.5.23",
-    "@swc/core-linux-arm64-gnu": "1.5.23",
-    "@swc/core-darwin-arm64": "1.5.23",
-    "@swc/core-linux-arm64-musl": "1.5.23",
-    "@swc/core-win32-arm64-msvc": "1.5.23"
+    "@swc/core-darwin-x64": "1.5.25",
+    "@swc/core-win32-x64-msvc": "1.5.25",
+    "@swc/core-linux-x64-gnu": "1.5.25",
+    "@swc/core-linux-x64-musl": "1.5.25",
+    "@swc/core-win32-ia32-msvc": "1.5.25",
+    "@swc/core-linux-arm-gnueabihf": "1.5.25",
+    "@swc/core-linux-arm64-gnu": "1.5.25",
+    "@swc/core-darwin-arm64": "1.5.25",
+    "@swc/core-linux-arm64-musl": "1.5.25",
+    "@swc/core-win32-arm64-msvc": "1.5.25"
   }
 }

package/spack.d.ts

@@ -0,0 +1,51 @@
+import { Options } from "@swc/types";
+export type BundleInput = BundleOptions | BundleOptions[];
+export declare const isLocalFile: RegExp;
+export declare function compileBundleOptions(config: BundleInput | string | undefined): Promise<BundleInput>;
+/**
+ * Usage: In `spack.config.js` / `spack.config.ts`, you can utilize type annotations (to get autocompletions) like
+ *
+ * ```ts
+ * import { config } from '@swc/core/spack';
+ *
+ * export default config({
+ *      name: 'web',
+ * });
+ * ```
+ *
+ *
+ *
+ */
+export declare function config(c: BundleInput): BundleInput;
+export interface BundleOptions extends SpackConfig {
+    workingDir?: string;
+}
+/**
+ * `spack.config,js`
+ */
+export interface SpackConfig {
+    /**
+     * @default process.env.NODE_ENV
+     */
+    mode?: Mode;
+    target?: Target;
+    entry: EntryConfig;
+    output: OutputConfig;
+    module: ModuleConfig;
+    options?: Options;
+    /**
+     * Modules to exclude from bundle.
+     */
+    externalModules?: string[];
+}
+export interface OutputConfig {
+    name: string;
+    path: string;
+}
+export interface ModuleConfig {
+}
+export type Mode = "production" | "development" | "none";
+export type Target = "browser" | "node";
+export type EntryConfig = string | string[] | {
+    [name: string]: string;
+};

package/spack.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.compileBundleOptions = exports.isLocalFile = void 0;
+const path = __importStar(require("path"));
+exports.isLocalFile = /^\.{0,2}\//; // starts with '/' './' '../'
+function compileBundleOptions(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const f = config === undefined ? "." : config;
+        try {
+            const filepath = typeof f === "string" ? f : "spack.config.js";
+            const fileModule = exports.isLocalFile.test(filepath)
+                ? path.resolve(filepath)
+                : filepath;
+            let configFromFile = require(fileModule);
+            if (configFromFile.default) {
+                configFromFile = configFromFile.default;
+            }
+            if (Array.isArray(configFromFile)) {
+                if (Array.isArray(f)) {
+                    return [...configFromFile, ...f];
+                }
+                if (typeof f !== "string") {
+                    configFromFile.push(f);
+                }
+                return configFromFile;
+            }
+            return Object.assign(Object.assign({}, configFromFile), (typeof config === "string" ? {} : config));
+        }
+        catch (e) {
+            if (typeof f === "string") {
+                throw new Error(`Error occurred while loading config file at ${config}: ${e}`);
+            }
+            return f;
+        }
+    });
+}
+exports.compileBundleOptions = compileBundleOptions;
+/**
+ * Usage: In `spack.config.js` / `spack.config.ts`, you can utilize type annotations (to get autocompletions) like
+ *
+ * ```ts
+ * import { config } from '@swc/core/spack';
+ *
+ * export default config({
+ *      name: 'web',
+ * });
+ * ```
+ *
+ *
+ *
+ */
+function config(c) {
+    return c;
+}
+exports.config = config;

package/util.d.ts

@@ -0,0 +1 @@
+export declare function wrapNativeSuper(Class: any): never;

package/util.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapNativeSuper = void 0;
+//@ts-ignore
+function wrapNativeSuper(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    //@ts-ignore
+    exports.wrapNativeSuper = wrapNativeSuper = function wrapNativeSuper(Class) {
+        if (Class === null || !_isNativeFunction(Class))
+            return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class))
+                return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            //@ts-ignore
+            return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true,
+            },
+        });
+        return _setPrototypeOf(Wrapper, Class);
+    };
+    return wrapNativeSuper(Class);
+}
+exports.wrapNativeSuper = wrapNativeSuper;
+function isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct)
+        return false;
+    //@ts-ignore
+    if (Reflect.construct.sham)
+        return false;
+    if (typeof Proxy === "function")
+        return true;
+    try {
+        Date.prototype.toString.call(Reflect.construct(Date, [], function () { }));
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+//@ts-ignore
+function _construct(Parent, args, Class) {
+    if (isNativeReflectConstruct()) {
+        //@ts-ignore
+        _construct = Reflect.construct;
+    }
+    else {
+        //@ts-ignore
+        _construct = function _construct(Parent, args, Class) {
+            var a = [null];
+            a.push.apply(a, args);
+            //@ts-ignore
+            var Constructor = Function.bind.apply(Parent, a);
+            //@ts-ignore
+            var instance = new Constructor();
+            if (Class)
+                _setPrototypeOf(instance, Class.prototype);
+            return instance;
+        };
+    }
+    //@ts-ignore
+    return _construct.apply(null, arguments);
+}
+function _isNativeFunction(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+//@ts-ignore
+function _setPrototypeOf(o, p) {
+    //@ts-ignore
+    _setPrototypeOf =
+        Object.setPrototypeOf ||
+            //@ts-ignore
+            function _setPrototypeOf(o, p) {
+                o.__proto__ = p;
+                return o;
+            };
+    return _setPrototypeOf(o, p);
+}
+//@ts-ignore
+function _getPrototypeOf(o) {
+    //@ts-ignore
+    _getPrototypeOf = Object.setPrototypeOf
+        ? Object.getPrototypeOf
+        : function _getPrototypeOf(
+        //@ts-ignore
+        o) {
+            return o.__proto__ || Object.getPrototypeOf(o);
+        };
+    return _getPrototypeOf(o);
+}
+module.exports = {
+    wrapNativeSuper,
+};