@granite-js/mpack 0.0.1

package/dist/shared/PersistentStorage.d.ts

@@ -0,0 +1,21 @@
+import { INTERNAL__Id } from '../types';
+/**
+ * 파일 시스템에 저장되는 데이터 (캐싱된 메타 데이터)
+ */
+interface PersistentData {
+    [id: INTERNAL__Id]: {
+        /**
+         * 번들링시 resolve 된 전체 모듈 수 (progress 계산에 사용)
+         */
+        totalModuleCount: number;
+    };
+}
+declare class PersistentStorage {
+    private data;
+    getData(): PersistentData;
+    setData(newData: Partial<PersistentData>): void;
+    loadData(): Promise<void>;
+    saveData(): Promise<void>;
+}
+export declare const persistentStorage: PersistentStorage;
+export {};

package/dist/shared/PersistentStorage.js

@@ -0,0 +1,68 @@
+"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 PersistentStorage_exports = {};
+__export(PersistentStorage_exports, {
+  persistentStorage: () => persistentStorage
+});
+module.exports = __toCommonJS(PersistentStorage_exports);
+var fs = __toESM(require("fs/promises"));
+var path = __toESM(require("path"));
+var import_es_toolkit = require("es-toolkit");
+var import_constants = require("../constants");
+class PersistentStorage {
+  data = {};
+  getData() {
+    return this.data;
+  }
+  setData(newData) {
+    this.data = (0, import_es_toolkit.toMerged)(this.data, newData);
+  }
+  async loadData() {
+    try {
+      await fs.access(import_constants.MPACK_DATA_DIR, fs.constants.R_OK | fs.constants.W_OK);
+    } catch {
+      await fs.mkdir(import_constants.MPACK_DATA_DIR, { recursive: true });
+    }
+    try {
+      this.data = JSON.parse(await fs.readFile(path.join(import_constants.MPACK_DATA_DIR, ".mpack"), "utf-8"));
+    } catch {
+    }
+  }
+  async saveData() {
+    try {
+      await fs.writeFile(path.join(import_constants.MPACK_DATA_DIR, ".mpack"), JSON.stringify(this.data, null, 2), "utf-8");
+    } catch {
+    }
+  }
+}
+const persistentStorage = new PersistentStorage();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  persistentStorage
+});

package/dist/transformer/AsyncTransformPipeline.d.ts

@@ -0,0 +1,4 @@
+import { TransformPipeline, TransformStepArgs, AsyncTransformStep, TransformStepResult } from './TransformPipeline';
+export declare class AsyncTransformPipeline extends TransformPipeline<AsyncTransformStep> {
+    transform(code: string, args: TransformStepArgs): Promise<TransformStepResult>;
+}

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,183 @@
+import * as swc from '@swc/core';
+import * as esbuild from 'esbuild';
+export interface BuildConfig {
+    /**
+     * 빌드 타겟 플랫폼
+     */
+    platform: 'ios' | 'android';
+    /**
+     * 빌드 진입점 파일 경로
+     */
+    entry: string;
+    /**
+     * 빌드 결과 파일 경로
+     */
+    outfile: string;
+    /**
+     * 소스맵 결과 파일 경로
+     *
+     * @default `${outfile}.map`
+     */
+    sourcemapOutfile?: string;
+    /**
+     * 모듈 resolution 구성
+     */
+    resolver?: {
+        /**
+         * 의존성 alias 구성
+         */
+        alias?: AliasConfig[];
+        /**
+         * 커스텀 모듈 Protocol 구성
+         */
+        protocols?: ProtocolConfig;
+    };
+    /**
+     * 커스텀 Transform 구성
+     */
+    transformSync?: (id: string, code: string) => string;
+    transformAsync?: (id: string, code: string) => Promise<string>;
+    /**
+     * esbuild 구성
+     */
+    esbuild?: esbuild.BuildOptions & {
+        /**
+         * Entry point 최상단에 주입할 스크립트 경로
+         *
+         * esbuild.inject 옵션에 추가한 스크립트의 경우 entry-point 모듈에만 주입되는 것이 아니라 모든 모듈에 주입되는 문제가 있음.
+         * entry-point 모듈의 최상단에만 코드를 주입하도록 별도 옵션을 구성합니다.
+         *
+         * - 의도한 것과 같이 entry-point 모듈 최상단에 1회만 주입(import)됩니다
+         * - 중복되는 inject 스크립트가 제거되어 번들 크기가 작아집니다
+         *
+         * @see issue {@link https://github.com/evanw/esbuild/issues/475}
+         */
+        prelude?: string[];
+    };
+    /**
+     * 커스텀 babel 구성
+     */
+    babel?: {
+        /**
+         * Babel transform 처리를 위한 규칙 리스트
+         * (속도가 느리기 때문에 특정 조건이 충족할 때에만 transform 하기 위한 옵션)
+         *
+         * 모든 규칙이 `false`를 반환할 경우 Babel transform 과정을 건너뜁니다
+         */
+        conditions?: Array<(code: string, path: string) => boolean>;
+        configFile?: string;
+        presets?: string[];
+        plugins?: (string | [string, any])[];
+    };
+    /**
+     * 커스텀 swc 구성
+     */
+    swc?: {
+        /**
+         * 플러그인 바이너리(wasm) 경로, 플러그인 구성
+         */
+        plugins?: NonNullable<swc.JscConfig['experimental']>['plugins'];
+    };
+    /**
+     * 추가 데이터
+     *
+     * 작업 결과 데이터에 포함되며, 특정 값을 기반으로 후처리 하기 위한 목적으로 사용
+     * (eg. 프리셋에서 특정 extra 데이터를 추가해주고, 결과에서 어떤 프리셋으로 빌드되었는지 구분)
+     *
+     * ```js
+     * const result = new Bundler({
+     *   bundlerConfig: {
+     *     buildConfig: {
+     *       extra: {
+     *         reanimated: 3,
+     *       },
+     *     },
+     *   },
+     *   ...
+     * }).build();
+     *
+     * if (result.extra?.reanimated === 3) {
+     *   // reav3 에 대한 빌드 결과물 처리
+     * }
+     * ```
+     */
+    extra?: any;
+}
+export interface AliasConfig {
+    /**
+     * 치환 대상 모듈 경로
+     */
+    from: string;
+    /**
+     * 치환할 모듈 경로 혹은 모듈 경로를 반환하는 함수
+     */
+    to: string | ((context: {
+        args: esbuild.OnResolveArgs;
+        resolve: esbuild.PluginBuild['resolve'];
+    }) => string | Promise<string>);
+    /**
+     * - `false`: (기본값) subpath 가 존재해도 치환합니다 (`^name(?:$|/)`)
+     * - `true`: 완벽히 일치하는 대상만 치환합니다 (`^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;
+}
+/**
+ * 커스텀 프로토콜 Resolve 구성
+ *
+ * 지정한 프로토콜로 참조하는 모듈을 직접 resolve, load 할 수 있도록 구성하는 옵션입니다
+ *
+ * ```ts
+ * // AS-IS
+ * import mod from 'custom-protocol:/path/to/module';
+ *
+ * // TO-BE
+ * // `custom-protocol:/path/to/module` 모듈은 아래와 같이 처리됨
+ * export default global.__import('/path/to/module');
+ * ```
+ *
+ * 구성 예시
+ *
+ * ```ts
+ * {
+ *   'custom-protocol': {
+ *     resolve: (args) => args.path,
+ *     load: (args) => {
+ *       return { loader: 'ts', contents: `export default global.__import('${args.path}')` };
+ *     },
+ *   },
+ * }
+ * ```
+ */
+export interface ProtocolConfig {
+    [name: string]: {
+        /**
+         * Resolve 할 모듈 경로
+         */
+        resolve?: (args: esbuild.OnResolveArgs) => string | Promise<string>;
+        /**
+         * Resolve 된 경로를 기준으로 모듈 코드를 반환
+         */
+        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,56 @@
+import { BuildConfig } from './BuildConfig';
+export interface BundlerConfig {
+    /**
+     * Task indentifier
+     */
+    tag: string;
+    /**
+     * Project root path
+     */
+    rootDir: string;
+    /**
+     * Application name
+     */
+    appName: string;
+    /**
+     * Scheme prefix
+     */
+    scheme: string;
+    /**
+     * Development mode
+     */
+    dev: boolean;
+    /**
+     * Enable transform caches
+     */
+    cache: boolean;
+    /**
+     * Generate metafile
+     */
+    metafile: boolean;
+    /**
+     * Build configuration
+     */
+    buildConfig: BuildConfig;
+    /**
+     * @deprecated
+     *
+     * Configuration for integrating external services
+     */
+    services?: ServiceConfig;
+}
+interface ServiceConfig {
+    sentry?: {
+        /**
+         * Defaults to `true`
+         */
+        enabled?: boolean;
+        /**
+         * Defaults to `process.env.SENTRY_AUTH_TOKEN`
+         */
+        authToken?: string;
+        org?: string;
+        project?: string;
+    };
+}
+export {};

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/Config.d.ts

@@ -0,0 +1,12 @@
+import type { DevServerConfig } from './DevServerConfig';
+import type { ServicesConfig } from './ServicesConfig';
+import type { TaskConfig } from './TaskConfig';
+export interface Config {
+    appName: string;
+    scheme: string;
+    commands?: unknown[];
+    concurrency?: number;
+    tasks: TaskConfig[];
+    devServer?: DevServerConfig;
+    services?: ServicesConfig;
+}

package/dist/types/Config.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 Config_exports = {};
+module.exports = __toCommonJS(Config_exports);

package/dist/types/DevServerConfig.d.ts

@@ -0,0 +1,9 @@
+import type { BuildConfig } from './BuildConfig';
+import type { Preset } from './Preset';
+export interface DevServerConfig {
+    /**
+     * 사전 구성된 프리셋
+     */
+    presets?: Preset[];
+    build: Omit<BuildConfig, 'platform' | 'outfile'>;
+}

package/dist/types/DevServerConfig.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 DevServerConfig_exports = {};
+module.exports = __toCommonJS(DevServerConfig_exports);

package/dist/types/Plugin.d.ts

@@ -0,0 +1,28 @@
+import type { INTERNAL__Id } from './TaskConfig';
+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/Preset.d.ts

@@ -0,0 +1,3 @@
+import { BuildConfig } from './BuildConfig';
+import type { PresetContext } from './PresetContext';
+export type Preset = (context: PresetContext) => Promise<Partial<BuildConfig>> | Partial<BuildConfig>;