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

package/binding.d.ts

@@ -0,0 +1,16 @@
+export const bundle: any;
+export const minify: any;
+export const minifySync: any;
+export const parse: any;
+export const parseSync: any;
+export const parseFileSync: any;
+export const parseFile: any;
+export const print: any;
+export const printSync: any;
+export const transform: any;
+export const transformSync: any;
+export const transformFile: any;
+export const transformFileSync: any;
+export const getTargetTriple: any;
+export const initCustomTraceSubscriber: any;
+export const Compiler: any;

package/binding.js

@@ -0,0 +1,283 @@
+"use strict";
+const { existsSync, readFileSync } = require('fs');
+const { join } = require('path');
+const { platform, arch } = process;
+let nativeBinding = null;
+let localFileExisted = false;
+let loadError = null;
+function isMusl() {
+    // For Node 10
+    if (!process.report || typeof process.report.getReport !== 'function') {
+        try {
+            return readFileSync('/usr/bin/ldd', 'utf8').includes('musl');
+        }
+        catch (e) {
+            return true;
+        }
+    }
+    else {
+        const { glibcVersionRuntime } = process.report.getReport().header;
+        return !glibcVersionRuntime;
+    }
+}
+switch (platform) {
+    case 'android':
+        switch (arch) {
+            case 'arm64':
+                localFileExisted = existsSync(join(__dirname, 'swc.android-arm64.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./swc.android-arm64.node');
+                    }
+                    else {
+                        nativeBinding = require('@swc/core-android-arm64');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            case 'arm':
+                localFileExisted = existsSync(join(__dirname, 'swc.android-arm-eabi.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./swc.android-arm-eabi.node');
+                    }
+                    else {
+                        nativeBinding = require('@swc/core-android-arm-eabi');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            default:
+                throw new Error(`Unsupported architecture on Android ${arch}`);
+        }
+        break;
+    case 'win32':
+        switch (arch) {
+            case 'x64':
+                localFileExisted = existsSync(join(__dirname, 'swc.win32-x64-msvc.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./swc.win32-x64-msvc.node');
+                    }
+                    else {
+                        nativeBinding = require('@swc/core-win32-x64-msvc');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            case 'ia32':
+                localFileExisted = existsSync(join(__dirname, 'swc.win32-ia32-msvc.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./swc.win32-ia32-msvc.node');
+                    }
+                    else {
+                        nativeBinding = require('@swc/core-win32-ia32-msvc');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            case 'arm64':
+                localFileExisted = existsSync(join(__dirname, 'swc.win32-arm64-msvc.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./swc.win32-arm64-msvc.node');
+                    }
+                    else {
+                        nativeBinding = require('@swc/core-win32-arm64-msvc');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            default:
+                throw new Error(`Unsupported architecture on Windows: ${arch}`);
+        }
+        break;
+    case 'darwin':
+        switch (arch) {
+            case 'x64':
+                localFileExisted = existsSync(join(__dirname, 'swc.darwin-x64.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./swc.darwin-x64.node');
+                    }
+                    else {
+                        nativeBinding = require('@swc/core-darwin-x64');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            case 'arm64':
+                localFileExisted = existsSync(join(__dirname, 'swc.darwin-arm64.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./swc.darwin-arm64.node');
+                    }
+                    else {
+                        nativeBinding = require('@swc/core-darwin-arm64');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            default:
+                throw new Error(`Unsupported architecture on macOS: ${arch}`);
+        }
+        break;
+    case 'freebsd':
+        if (arch !== 'x64') {
+            throw new Error(`Unsupported architecture on FreeBSD: ${arch}`);
+        }
+        localFileExisted = existsSync(join(__dirname, 'swc.freebsd-x64.node'));
+        try {
+            if (localFileExisted) {
+                nativeBinding = require('./swc.freebsd-x64.node');
+            }
+            else {
+                nativeBinding = require('@swc/core-freebsd-x64');
+            }
+        }
+        catch (e) {
+            loadError = e;
+        }
+        break;
+    case 'openharmony':
+        // [ohos-port] self-contained HarmonyOS binding: prefer bundled swc.openharmony-arm64.node
+        switch (arch) {
+            case 'arm64':
+                localFileExisted = existsSync(join(__dirname, 'swc.openharmony-arm64.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./swc.openharmony-arm64.node');
+                    }
+                    else {
+                        nativeBinding = require('@swc/core-openharmony-arm64');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            default:
+                throw new Error(`Unsupported architecture on OpenHarmony ${arch}`);
+        }
+        break;
+    case 'linux':
+        switch (arch) {
+            case 'x64':
+                if (isMusl()) {
+                    localFileExisted = existsSync(join(__dirname, 'swc.linux-x64-musl.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./swc.linux-x64-musl.node');
+                        }
+                        else {
+                            nativeBinding = require('@swc/core-linux-x64-musl');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                else {
+                    localFileExisted = existsSync(join(__dirname, 'swc.linux-x64-gnu.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./swc.linux-x64-gnu.node');
+                        }
+                        else {
+                            nativeBinding = require('@swc/core-linux-x64-gnu');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                break;
+            case 'arm64':
+                if (isMusl()) {
+                    localFileExisted = existsSync(join(__dirname, 'swc.linux-arm64-musl.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./swc.linux-arm64-musl.node');
+                        }
+                        else {
+                            nativeBinding = require('@swc/core-linux-arm64-musl');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                else {
+                    localFileExisted = existsSync(join(__dirname, 'swc.linux-arm64-gnu.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./swc.linux-arm64-gnu.node');
+                        }
+                        else {
+                            nativeBinding = require('@swc/core-linux-arm64-gnu');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                break;
+            case 'arm':
+                localFileExisted = existsSync(join(__dirname, 'swc.linux-arm-gnueabihf.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./swc.linux-arm-gnueabihf.node');
+                    }
+                    else {
+                        nativeBinding = require('@swc/core-linux-arm-gnueabihf');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            default:
+                throw new Error(`Unsupported architecture on Linux: ${arch}`);
+        }
+        break;
+    default:
+        throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`);
+}
+if (!nativeBinding) {
+    if (loadError) {
+        throw loadError;
+    }
+    throw new Error(`Failed to load native binding`);
+}
+const { bundle, minify, minifySync, parse, parseSync, parseFileSync, parseFile, print, printSync, transform, transformSync, transformFile, transformFileSync, getTargetTriple, initCustomTraceSubscriber, Compiler } = nativeBinding;
+module.exports.bundle = bundle;
+module.exports.minify = minify;
+module.exports.minifySync = minifySync;
+module.exports.parse = parse;
+module.exports.parseSync = parseSync;
+module.exports.parseFileSync = parseFileSync;
+module.exports.parseFile = parseFile;
+module.exports.print = print;
+module.exports.printSync = printSync;
+module.exports.transform = transform;
+module.exports.transformSync = transformSync;
+module.exports.transformFile = transformFile;
+module.exports.transformFileSync = transformFileSync;
+module.exports.getTargetTriple = getTargetTriple;
+module.exports.initCustomTraceSubscriber = initCustomTraceSubscriber;
+module.exports.Compiler = Compiler;

package/index.d.ts

@@ -0,0 +1,107 @@
+import { Plugin, ParseOptions, Module, Output, Options, Script, Program, JsMinifyOptions } from "./types";
+export * from "./types";
+import { BundleInput } from "./spack";
+/**
+ * Version of the swc binding.
+ */
+export declare const version: string;
+export declare function plugins(ps: Plugin[]): Plugin;
+export declare class Compiler {
+    private fallbackBindingsPluginWarningDisplayed;
+    minify(src: string, opts?: JsMinifyOptions): Promise<Output>;
+    minifySync(src: string, opts?: JsMinifyOptions): Output;
+    parse(src: string, options: ParseOptions & {
+        isModule: false;
+    }): Promise<Script>;
+    parse(src: string, options?: ParseOptions, filename?: string): Promise<Module>;
+    parseSync(src: string, options: ParseOptions & {
+        isModule: false;
+    }): Script;
+    parseSync(src: string, options?: ParseOptions, filename?: string): Module;
+    parseFile(path: string, options: ParseOptions & {
+        isModule: false;
+    }): Promise<Script>;
+    parseFile(path: string, options?: ParseOptions): Promise<Module>;
+    parseFileSync(path: string, options: ParseOptions & {
+        isModule: false;
+    }): Script;
+    parseFileSync(path: string, options?: ParseOptions): Module;
+    /**
+     * Note: this method should be invoked on the compiler instance used
+     *  for `parse()` / `parseSync()`.
+     */
+    print(m: Program, options?: Options): Promise<Output>;
+    /**
+     * Note: this method should be invoked on the compiler instance used
+     *  for `parse()` / `parseSync()`.
+     */
+    printSync(m: Program, options?: Options): Output;
+    transform(src: string | Program, options?: Options): Promise<Output>;
+    transformSync(src: string | Program, options?: Options): Output;
+    transformFile(path: string, options?: Options): Promise<Output>;
+    transformFileSync(path: string, options?: Options): Output;
+    bundle(options?: BundleInput | string): Promise<{
+        [name: string]: Output;
+    }>;
+}
+export declare function parse(src: string, options: ParseOptions & {
+    isModule: false;
+}): Promise<Script>;
+export declare function parse(src: string, options?: ParseOptions): Promise<Module>;
+export declare function parseSync(src: string, options: ParseOptions & {
+    isModule: false;
+}): Script;
+export declare function parseSync(src: string, options?: ParseOptions): Module;
+export declare function parseFile(path: string, options: ParseOptions & {
+    isModule: false;
+}): Promise<Script>;
+export declare function parseFile(path: string, options?: ParseOptions): Promise<Module>;
+export declare function parseFileSync(path: string, options: ParseOptions & {
+    isModule: false;
+}): Script;
+export declare function parseFileSync(path: string, options?: ParseOptions): Module;
+export declare function print(m: Program, options?: Options): Promise<Output>;
+export declare function printSync(m: Program, options?: Options): Output;
+export declare function transform(src: string | Program, options?: Options): Promise<Output>;
+export declare function transformSync(src: string | Program, options?: Options): Output;
+export declare function transformFile(path: string, options?: Options): Promise<Output>;
+export declare function transformFileSync(path: string, options?: Options): Output;
+export declare function bundle(options?: BundleInput | string): Promise<{
+    [name: string]: Output;
+}>;
+export declare function minify(src: string, opts?: JsMinifyOptions): Promise<Output>;
+export declare function minifySync(src: string, opts?: JsMinifyOptions): Output;
+/**
+ * Configure custom trace configuration runs for a process lifecycle.
+ * Currently only chromium's trace event format is supported.
+ * (https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview)
+ *
+ * This should be called before calling any binding interfaces exported in `@swc/core`, such as
+ * `transform*`, or `parse*` or anything. To avoid breaking changes, each binding fn internally
+ * sets default trace subscriber if not set.
+ *
+ * Unlike other configuration, this does not belong to individual api surface using swcrc
+ * or api's parameters (`transform(..., {trace})`). This is due to current tracing subscriber
+ * can be configured only once for the global scope. Calling `registerGlobalTraceConfig` multiple
+ * time won't cause error, subsequent calls will be ignored.
+ *
+ * As name implies currently this is experimental interface may change over time without semver
+ * major breaking changes. Please provide feedbacks,
+ * or bug report at https://github.com/swc-project/swc/discussions.
+ */
+export declare function __experimental_registerGlobalTraceConfig(traceConfig: {
+    type: 'traceEvent';
+    fileName?: string;
+}): void;
+/**
+ * @ignore
+ *
+ * Returns current binary's metadata to determine which binary is actually loaded.
+ *
+ * This is undocumented interface, does not guarantee stability across `@swc/core`'s semver
+ * as internal representation may change anytime. Use it with caution.
+ */
+export declare function getBinaryMetadata(): {
+    target: string | undefined;
+};
+export declare const DEFAULT_EXTENSIONS: readonly string[];