@ohos-ports/swc-core 1.3.14-beta.0

package/run_swcx.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Lightweight entrypoint to native swc cli binary.
+ *
+ * This is to locate corresponding per-platform executables correctly, as well as
+ * let npm links binary to `node_modules/.bin` allows npm-related ecosystem (`npx swcx`, etcs)
+ * works correctly. However, it means spawning native binary still requires warmup from node.js
+ * process.
+ *
+ * NOTE: THIS IS NOT A PERMANENT APPROACH.
+ * Distribution of native cli binary is not fully concluded yet. This allows easier
+ * opt-in while implementation is in progress to collect feedback.
+ */
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const { platform, arch } = process;
+const isMusl = () => (() => {
+    function isMusl() {
+        if (!process.report || typeof process.report.getReport !== "function") {
+            try {
+                return (0, fs_1.readFileSync)("/usr/bin/ldd", "utf8").includes("musl");
+            }
+            catch (e) {
+                return true;
+            }
+        }
+        else {
+            const { glibcVersionRuntime } = process.report.getReport().header;
+            return !glibcVersionRuntime;
+        }
+    }
+    return isMusl();
+})();
+const platformPackagesMap = {
+    "android": {
+        "arm64": "@swc/core-android-arm64",
+        "arm": "@swc/core-android-arm-eabi",
+    },
+    "win32": {
+        "x64": "@swc/core-win32-x64-msvc",
+        "ia32": "@swc/core-win32-ia32-msvc",
+        "arm64": "@swc/core-win32-arm64-msvc"
+    },
+    "darwin": {
+        "x64": "@swc/core-darwin-x64",
+        "arm64": "@swc/core-darwin-arm64",
+    },
+    "freebsd": {
+        "x64": "@swc/core-freebsd-x64",
+    },
+    "linux": {
+        "x64": `@swc/core-linux-x64-${isMusl() ? 'musl' : 'gnu'}`,
+        "arm64": `@swc/core-linux-arm64-${isMusl() ? 'musl' : 'gnu'}`,
+        "arm": "@swc/core-linux-arm64-gnu"
+    },
+};
+const inferBinaryName = () => {
+    const packageName = platformPackagesMap[platform][arch];
+    if (!packageName) {
+        throw new Error(`Unsupported platform: binary for '${platform} ${arch}' is not available`);
+    }
+    return path_1.default.join(path_1.default.dirname(require.resolve(packageName)), platform === 'win32' ? 'swc.exe' : 'swc');
+};
+const executeBinary = () => __awaiter(void 0, void 0, void 0, function* () {
+    const binary = inferBinaryName();
+    const [, , ...args] = process.argv;
+    const options = { cwd: process.cwd(), stdio: "inherit" };
+    return (0, child_process_1.spawn)(binary, args, options);
+});
+executeBinary().catch((e) => console.error(e));

package/spack.d.ts

@@ -0,0 +1,50 @@
+import { Options } from "./types";
+export declare type BundleInput = BundleOptions | BundleOptions[];
+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 declare type Mode = 'production' | 'development' | 'none';
+export declare type Target = 'browser' | 'node';
+export declare type EntryConfig = string | string[] | {
+    [name: string]: string;
+};

package/spack.js

@@ -0,0 +1,83 @@
+"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 = void 0;
+const path = __importStar(require("path"));
+function compileBundleOptions(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const f = config === undefined ? '.' : config;
+        try {
+            const file = typeof f === 'string' ? f : path.resolve('spack.config.js');
+            let configFromFile = require(file);
+            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/swc.openharmony-arm64.node

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: package/swc.openharmony-arm64.node
+size: 38147712 bytes
+sha256: c871faa0015d9c31e41731f00078f4295a3fe47625c885e72e9ac02801c57259