@granite-js/mpack 0.0.0-dev-20250725013859

package/dist/transformer/AsyncTransformPipeline.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AsyncTransformPipeline_exports = {};
+__export(AsyncTransformPipeline_exports, {
+  AsyncTransformPipeline: () => AsyncTransformPipeline
+});
+module.exports = __toCommonJS(AsyncTransformPipeline_exports);
+var import_TransformPipeline = require("./TransformPipeline");
+var import_performance = require("../performance");
+class AsyncTransformPipeline extends import_TransformPipeline.TransformPipeline {
+  async transform(code, args) {
+    const context = await this.getStepContext(args);
+    const before = (code2, args2, context2) => {
+      return this._beforeStep ? this._beforeStep(code2, args2, context2) : Promise.resolve({ code: code2, done: false });
+    };
+    const after = (code2, args2, context2) => {
+      return this._afterStep ? this._afterStep(code2, args2, context2) : Promise.resolve({ code: code2, done: true });
+    };
+    let result = await before(code, args, context);
+    for await (const [step, config] of this.steps) {
+      if (result.done) {
+        break;
+      }
+      if (config?.conditions == null || Array.isArray(config?.conditions) && config.conditions.some((condition) => condition(result.code, args.path))) {
+        let trace;
+        if (typeof step.name === "string") {
+          trace = import_performance.Performance.trace(`step-${step.name}`, { detail: { file: args.path } });
+        }
+        result = await step(result.code, args, context);
+        trace?.stop();
+        if (config?.skipOtherSteps) {
+          break;
+        }
+      }
+    }
+    return after(result.code, args, context);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AsyncTransformPipeline
+});

package/dist/transformer/TransformPipeline.d.ts

@@ -0,0 +1,37 @@
+export interface TransformStepArgs {
+    path: string;
+}
+export interface TransformStepContext {
+    key: string;
+    mtimeMs: number;
+}
+export interface TransformStepResult {
+    code: string;
+    done?: boolean;
+}
+interface TransformStep<TransformResult> {
+    (code: string, args: TransformStepArgs, context: TransformStepContext): TransformResult;
+    name?: string;
+}
+interface TransformStepConfig {
+    /**
+     * step 을 실행하기 위한 조건 (기본값: 항상 실행)
+     */
+    conditions?: Array<(code: string, path: string) => boolean>;
+    /**
+     * 현재 step 이 실행된 경우 done 처리 여부 (기본값: false)
+     */
+    skipOtherSteps?: boolean;
+}
+export type AsyncTransformStep = TransformStep<Promise<TransformStepResult>>;
+export declare abstract class TransformPipeline<Step extends TransformStep<unknown>> {
+    protected _beforeStep?: Step;
+    protected _afterStep?: Step;
+    protected steps: Array<[Step, TransformStepConfig | null]>;
+    beforeStep(step: Step): this;
+    afterStep(step: Step): this;
+    addStep(step: Step, config?: TransformStepConfig): this;
+    getStepContext(args: TransformStepArgs): Promise<TransformStepContext>;
+    abstract transform(code: string, args: TransformStepArgs): ReturnType<Step>;
+}
+export {};

package/dist/transformer/TransformPipeline.js

@@ -0,0 +1,64 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TransformPipeline_exports = {};
+__export(TransformPipeline_exports, {
+  TransformPipeline: () => TransformPipeline
+});
+module.exports = __toCommonJS(TransformPipeline_exports);
+var fs = __toESM(require("fs/promises"));
+var import_performance = require("../performance");
+var import_md5 = require("../utils/md5");
+class TransformPipeline {
+  _beforeStep;
+  _afterStep;
+  steps = [];
+  beforeStep(step) {
+    this._beforeStep = step;
+    return this;
+  }
+  afterStep(step) {
+    this._afterStep = step;
+    return this;
+  }
+  addStep(step, config) {
+    this.steps.push([step, config ?? null]);
+    return this;
+  }
+  async getStepContext(args) {
+    const trace = import_performance.Performance.trace("get-step-context");
+    const { mtimeMs } = await fs.stat(args.path);
+    const key = (0, import_md5.md5)(args.path, mtimeMs);
+    trace.stop();
+    return { key, mtimeMs };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransformPipeline
+});

package/dist/transformer/index.d.ts

@@ -0,0 +1 @@
+export { AsyncTransformPipeline } from './AsyncTransformPipeline';

package/dist/transformer/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transformer_exports = {};
+__export(transformer_exports, {
+  AsyncTransformPipeline: () => import_AsyncTransformPipeline.AsyncTransformPipeline
+});
+module.exports = __toCommonJS(transformer_exports);
+var import_AsyncTransformPipeline = require("./AsyncTransformPipeline");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AsyncTransformPipeline
+});

package/dist/types/BuildConfig.d.ts

@@ -0,0 +1,187 @@
+import * as swc from '@swc/core';
+import * as esbuild from 'esbuild';
+export interface BuildConfig {
+    /**
+     * Build platform
+     */
+    platform: 'ios' | 'android';
+    /**
+     * Entry file path
+     */
+    entry: string;
+    /**
+     * Build output file path
+     */
+    outfile: string;
+    /**
+     * Source map output file path
+     *
+     * @default `${outfile}.map`
+     */
+    sourcemapOutfile?: string;
+    /**
+     * Module resolution configuration
+     */
+    resolver?: {
+        /**
+         * Dependency alias configuration
+         */
+        alias?: AliasConfig[];
+        /**
+         * Custom module protocol configuration
+         */
+        protocols?: ProtocolConfig;
+    };
+    /**
+     * Transformer configuration
+     */
+    transformer?: {
+        transformSync?: TransformSync;
+        transformAsync?: TransformAsync;
+    };
+    /**
+     * esbuild configuration
+     */
+    esbuild?: esbuild.BuildOptions & {
+        /**
+         * Script path to inject at the entry point
+         *
+         * esbuild.inject option added script is not only injected into the entry-point module, but also into all modules.
+         * entry-point module's top level only inject code.
+         *
+         * - injected only once at the top level of the entry-point module
+         * - duplicate inject script is removed, reducing bundle size
+         *
+         * @see issue {@link https://github.com/evanw/esbuild/issues/475}
+         */
+        prelude?: string[];
+    };
+    /**
+     * Custom babel configuration
+     */
+    babel?: {
+        /**
+         * List of rules for Babel transform processing
+         * (option to skip Babel transform only when certain conditions are met)
+         *
+         * If all rules return `false`, Babel transform is skipped
+         */
+        conditions?: Array<(code: string, path: string) => boolean>;
+        configFile?: string;
+        presets?: string[];
+        plugins?: (string | [string, any])[];
+    };
+    /**
+     * Custom swc configuration
+     */
+    swc?: {
+        /**
+         * Plugin binary(wasm) path, plugin configuration
+         */
+        plugins?: NonNullable<swc.JscConfig['experimental']>['plugins'];
+    };
+    /**
+     * Additional data
+     *
+     * Included in the build result data, used for post-processing based on specific values
+     * (eg. add specific extra data in preset, and distinguish which preset the build result is from)
+     *
+     * ```js
+     * const result = new Bundler({
+     *   bundlerConfig: {
+     *     buildConfig: {
+     *       extra: {
+     *         reanimated: 3,
+     *       },
+     *     },
+     *   },
+     *   ...
+     * }).build();
+     *
+     * if (result.extra?.reanimated === 3) {
+     *   // handle build result for reanimated v3
+     * }
+     * ```
+     */
+    extra?: any;
+}
+export type TransformSync = (id: string, code: string) => string;
+export type TransformAsync = (id: string, code: string) => Promise<string>;
+export interface AliasConfig {
+    /**
+     * Replacement target module path
+     */
+    from: string;
+    /**
+     * Replacement module path or function that returns module path
+     */
+    to: string | ((context: {
+        args: esbuild.OnResolveArgs;
+        resolve: esbuild.PluginBuild['resolve'];
+    }) => string | Promise<string>);
+    /**
+     * - `false`: (default) replace even if subpath exists (`^name(?:$|/)`)
+     * - `true`: replace only if the target is exactly matched (`^name$`)
+     *
+     * ```js
+     * const config = {
+     *   alias: [
+     *    { from: 'react-native', to: 'react-native-0.68' },
+     *    { from: 'react', to: 'react-17', exact: true },
+     *   ],
+     * };
+     *
+     * // AS IS
+     * import * as RN from 'react-native';
+     * import 'react-native/Libraries/Core/InitializeCore';
+     * import React from 'react';
+     * import runtime from 'react/runtime';
+     *
+     * // TO BE
+     * import * as RN from 'react-native-0.68';
+     * import 'react-native-0.68/Libraries/Core/InitializeCore';
+     * import React from 'react-17';
+     * import runtime from 'react/runtime'; // exact
+     * ```
+     */
+    exact?: boolean;
+}
+/**
+ * Custom protocol resolve configuration
+ *
+ * This option configures to directly resolve and load modules referenced by the specified protocol
+ *
+ * ```ts
+ * // AS-IS
+ * import mod from 'custom-protocol:/path/to/module';
+ *
+ * // TO-BE
+ * // `custom-protocol:/path/to/module` module is handled as follows
+ * export default global.__import('/path/to/module');
+ * ```
+ *
+ * Configuration example
+ *
+ * ```ts
+ * {
+ *   'custom-protocol': {
+ *     resolve: (args) => args.path,
+ *     load: (args) => {
+ *       return { loader: 'ts', contents: `export default global.__import('${args.path}')` };
+ *     },
+ *   },
+ * }
+ * ```
+ */
+export interface ProtocolConfig {
+    [name: string]: {
+        /**
+         * Module path to resolve
+         */
+        resolve?: (args: esbuild.OnResolveArgs) => string | Promise<string>;
+        /**
+         * Return module code based on the resolved path
+         */
+        load: (args: esbuild.OnLoadArgs) => esbuild.OnLoadResult | Promise<esbuild.OnLoadResult>;
+    };
+}

package/dist/types/BuildConfig.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var BuildConfig_exports = {};
+module.exports = __toCommonJS(BuildConfig_exports);

package/dist/types/BundlerConfig.d.ts

@@ -0,0 +1,23 @@
+import { BuildConfig } from './BuildConfig';
+export interface BundlerConfig {
+    /**
+     * Project root path
+     */
+    rootDir: string;
+    /**
+     * Development mode
+     */
+    dev: boolean;
+    /**
+     * Enable transform caches
+     */
+    cache: boolean;
+    /**
+     * Generate metafile
+     */
+    metafile: boolean;
+    /**
+     * Build configuration
+     */
+    buildConfig: BuildConfig;
+}

package/dist/types/BundlerConfig.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var BundlerConfig_exports = {};
+module.exports = __toCommonJS(BundlerConfig_exports);

package/dist/types/DevServer.d.ts

@@ -0,0 +1,10 @@
+import type { HandleFunction } from 'connect';
+import type { FastifyPluginAsync, FastifyPluginCallback } from 'fastify';
+export type Middleware = FastifyPluginAsync | FastifyPluginCallback;
+export type MetroMiddleware = HandleFunction;
+export interface DevServerConfig {
+    middlewares?: Middleware[];
+}
+export interface MetroDevServerConfig {
+    middlewares?: MetroMiddleware[];
+}

package/dist/types/DevServer.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DevServer_exports = {};
+module.exports = __toCommonJS(DevServer_exports);

package/dist/types/Id.d.ts

@@ -0,0 +1,3 @@
+export type INTERNAL__Id = string & {
+    __id: true;
+};

package/dist/types/Id.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Id_exports = {};
+module.exports = __toCommonJS(Id_exports);

package/dist/types/Plugin.d.ts

@@ -0,0 +1,28 @@
+import type { INTERNAL__Id } from './Id';
+import type { BuildResult } from '../bundler/types';
+import type { BundlerConfig } from '../types/BundlerConfig';
+export interface Plugin extends Partial<BindThis<PluginHooks, PluginContext>> {
+    name?: string;
+}
+export type Hooks = keyof Partial<PluginHooks>;
+export type PluginHooks = {
+    [K in keyof FunctionPluginHooks]: FunctionPluginHooks[K];
+};
+interface FunctionPluginHooks {
+    prepare(config: BundlerConfig): void;
+    buildStart(): void;
+    buildEnd(buildResult: BuildResult): void;
+    load(moduleCount: number): void;
+}
+type BindThis<T, ThisType> = {
+    [K in keyof T]: T[K] extends (...args: infer Args) => infer R ? (this: ThisType, ...args: Args) => R : T[K];
+};
+interface PluginContext {
+    id: INTERNAL__Id;
+}
+export type PluginHandlers = {
+    onStart?: () => void;
+    onEnd?: () => void;
+};
+export type PluginFactory = (handlers?: PluginHandlers) => Plugin;
+export {};

package/dist/types/Plugin.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Plugin_exports = {};
+module.exports = __toCommonJS(Plugin_exports);

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './BuildConfig';
+export * from './BundlerConfig';
+export * from './Plugin';
+export * from './Id';
+export * from './DevServer';

package/dist/types/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./BuildConfig"), module.exports);
+__reExport(types_exports, require("./BundlerConfig"), module.exports);
+__reExport(types_exports, require("./Plugin"), module.exports);
+__reExport(types_exports, require("./Id"), module.exports);
+__reExport(types_exports, require("./DevServer"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./BuildConfig"),
+  ...require("./BundlerConfig"),
+  ...require("./Plugin"),
+  ...require("./Id"),
+  ...require("./DevServer")
+});