@utoo/pack 0.0.1-alpha.1

package/cjs/magicIdentifier.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAGIC_IDENTIFIER_REGEX = void 0;
+exports.decodeMagicIdentifier = decodeMagicIdentifier;
+function decodeHex(hexStr) {
+    if (hexStr.trim() === "") {
+        throw new Error("can't decode empty hex");
+    }
+    const num = parseInt(hexStr, 16);
+    if (isNaN(num)) {
+        throw new Error(`invalid hex: \`${hexStr}\``);
+    }
+    return String.fromCodePoint(num);
+}
+const DECODE_REGEX = /^__TURBOPACK__([a-zA-Z0-9_$]+)__$/;
+function decodeMagicIdentifier(identifier) {
+    const matches = identifier.match(DECODE_REGEX);
+    if (!matches) {
+        return identifier;
+    }
+    const inner = matches[1];
+    let output = "";
+    let mode = 0 /* Mode.Text */;
+    let buffer = "";
+    for (let i = 0; i < inner.length; i++) {
+        const char = inner[i];
+        if (mode === 0 /* Mode.Text */) {
+            if (char === "_") {
+                mode = 1 /* Mode.Underscore */;
+            }
+            else if (char === "$") {
+                mode = 2 /* Mode.Hex */;
+            }
+            else {
+                output += char;
+            }
+        }
+        else if (mode === 1 /* Mode.Underscore */) {
+            if (char === "_") {
+                output += " ";
+                mode = 0 /* Mode.Text */;
+            }
+            else if (char === "$") {
+                output += "_";
+                mode = 2 /* Mode.Hex */;
+            }
+            else {
+                output += char;
+                mode = 0 /* Mode.Text */;
+            }
+        }
+        else if (mode === 2 /* Mode.Hex */) {
+            if (buffer.length === 2) {
+                output += decodeHex(buffer);
+                buffer = "";
+            }
+            if (char === "_") {
+                if (buffer !== "") {
+                    throw new Error(`invalid hex: \`${buffer}\``);
+                }
+                mode = 3 /* Mode.LongHex */;
+            }
+            else if (char === "$") {
+                if (buffer !== "") {
+                    throw new Error(`invalid hex: \`${buffer}\``);
+                }
+                mode = 0 /* Mode.Text */;
+            }
+            else {
+                buffer += char;
+            }
+        }
+        else if (mode === 3 /* Mode.LongHex */) {
+            if (char === "_") {
+                throw new Error(`invalid hex: \`${buffer + char}\``);
+            }
+            else if (char === "$") {
+                output += decodeHex(buffer);
+                buffer = "";
+                mode = 0 /* Mode.Text */;
+            }
+            else {
+                buffer += char;
+            }
+        }
+    }
+    return output;
+}
+exports.MAGIC_IDENTIFIER_REGEX = /__TURBOPACK__[a-zA-Z0-9_$]+__/g;

package/cjs/project.d.ts

@@ -0,0 +1,43 @@
+import * as binding from "./binding";
+import type { NapiWrittenEndpoint, StackFrame } from "./binding";
+import { ProjectOptions, RawEntrypoints, Update } from "./types";
+export declare class TurbopackInternalError extends Error {
+    name: string;
+    constructor(cause: Error);
+}
+export declare function projectFactory(): (options: ProjectOptions, turboEngineOptions: binding.NapiTurboEngineOptions) => Promise<{
+    readonly _nativeProject: {
+        __napiType: "Project";
+    };
+    update(options: Partial<ProjectOptions>): Promise<void>;
+    writeAllEntrypointsToDisk(): Promise<TurbopackResult<RawEntrypoints>>;
+    entrypointsSubscribe(): AsyncGenerator<{
+        apps: {
+            readonly _nativeEndpoint: {
+                __napiType: "Endpoint";
+            };
+            writeToDisk(): Promise<TurbopackResult<NapiWrittenEndpoint>>;
+            clientChanged(): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
+            serverChanged(includeIssues: boolean): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
+        }[];
+        libraries: {
+            readonly _nativeEndpoint: {
+                __napiType: "Endpoint";
+            };
+            writeToDisk(): Promise<TurbopackResult<NapiWrittenEndpoint>>;
+            clientChanged(): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
+            serverChanged(includeIssues: boolean): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
+        }[];
+        issues: binding.NapiIssue[];
+        diagnostics: binding.NapiDiagnostic[];
+    }, void, unknown>;
+    hmrEvents(identifier: string): AsyncIterableIterator<TurbopackResult<Update>>;
+    hmrIdentifiersSubscribe(): AsyncIterableIterator<TurbopackResult<binding.HmrIdentifiers>>;
+    traceSource(stackFrame: StackFrame, currentDirectoryFileUrl: string): Promise<StackFrame | null>;
+    getSourceForAsset(filePath: string): Promise<string | null>;
+    getSourceMap(filePath: string): Promise<string | null>;
+    getSourceMapSync(filePath: string): string | null;
+    updateInfoSubscribe(aggregationMs: number): AsyncIterableIterator<TurbopackResult<binding.NapiUpdateMessage>>;
+    shutdown(): Promise<void>;
+    onExit(): Promise<void>;
+}>;

package/cjs/project.js

@@ -0,0 +1,290 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurbopackInternalError = void 0;
+exports.projectFactory = projectFactory;
+const util_1 = require("util");
+const binding = __importStar(require("./binding"));
+const nanoid_1 = require("nanoid");
+class TurbopackInternalError extends Error {
+    constructor(cause) {
+        super(cause.message);
+        this.name = "TurbopackInternalError";
+        this.stack = cause.stack;
+    }
+}
+exports.TurbopackInternalError = TurbopackInternalError;
+async function withErrorCause(fn) {
+    try {
+        return await fn();
+    }
+    catch (nativeError) {
+        throw new TurbopackInternalError(nativeError);
+    }
+}
+function ensureLoadersHaveSerializableOptions(turbopackRules) {
+    for (const [glob, rule] of Object.entries(turbopackRules)) {
+        if (Array.isArray(rule)) {
+            checkLoaderItems(rule, glob);
+        }
+        else {
+            checkConfigItem(rule, glob);
+        }
+    }
+    function checkConfigItem(rule, glob) {
+        if (!rule)
+            return;
+        if ("loaders" in rule) {
+            checkLoaderItems(rule.loaders, glob);
+        }
+        else {
+            for (const key in rule) {
+                const inner = rule[key];
+                if (typeof inner === "object" && inner) {
+                    checkConfigItem(inner, glob);
+                }
+            }
+        }
+    }
+    function checkLoaderItems(loaderItems, glob) {
+        for (const loaderItem of loaderItems) {
+            if (typeof loaderItem !== "string" &&
+                !(0, util_1.isDeepStrictEqual)(loaderItem, JSON.parse(JSON.stringify(loaderItem)))) {
+                throw new Error(`loader ${loaderItem.loader} for match "${glob}" does not have serializable options. Ensure that options passed are plain JavaScript objects and values.`);
+            }
+        }
+    }
+}
+async function serializeConfig(config) {
+    var _a, _b;
+    let configSerializable = { ...config };
+    configSerializable.generateBuildId = () => (0, nanoid_1.nanoid)();
+    if ((_a = configSerializable.module) === null || _a === void 0 ? void 0 : _a.rules) {
+        ensureLoadersHaveSerializableOptions(configSerializable.module.rules);
+    }
+    if (configSerializable.optimization) {
+        configSerializable.optimization.modularizeImports =
+            configSerializable.optimization &&
+                ((_b = configSerializable.optimization) === null || _b === void 0 ? void 0 : _b.modularizeImports)
+                ? Object.fromEntries(Object.entries(configSerializable.optimization.modularizeImports).map(([mod, config]) => [
+                    mod,
+                    {
+                        ...config,
+                        transform: typeof config.transform === "string"
+                            ? config.transform
+                            : Object.entries(config.transform).map(([key, value]) => [
+                                key,
+                                value,
+                            ]),
+                    },
+                ]))
+                : undefined;
+    }
+    return JSON.stringify(configSerializable, null, 2);
+}
+function rustifyEnv(env) {
+    return Object.entries(env)
+        .filter(([_, value]) => value != null)
+        .map(([name, value]) => ({
+        name,
+        value,
+    }));
+}
+async function rustifyPartialProjectOptions(options) {
+    return {
+        ...options,
+        config: options.config && (await serializeConfig(options.config)),
+        processEnv: options.processEnv && rustifyEnv(options.processEnv),
+    };
+}
+async function rustifyProjectOptions(options) {
+    var _a;
+    return {
+        ...options,
+        config: await serializeConfig(options.config),
+        processEnv: rustifyEnv((_a = options.processEnv) !== null && _a !== void 0 ? _a : {}),
+    };
+}
+function projectFactory() {
+    const cancel = new (class Cancel extends Error {
+    })();
+    function subscribe(useBuffer, nativeFunction) {
+        // A buffer of produced items. This will only contain values if the
+        // consumer is slower than the producer.
+        let buffer = [];
+        // A deferred value waiting for the next produced item. This will only
+        // exist if the consumer is faster than the producer.
+        let waiting;
+        let canceled = false;
+        // The native function will call this every time it emits a new result. We
+        // either need to notify a waiting consumer, or buffer the new result until
+        // the consumer catches up.
+        function emitResult(err, value) {
+            if (waiting) {
+                let { resolve, reject } = waiting;
+                waiting = undefined;
+                if (err)
+                    reject(err);
+                else
+                    resolve(value);
+            }
+            else {
+                const item = { err, value };
+                if (useBuffer)
+                    buffer.push(item);
+                else
+                    buffer[0] = item;
+            }
+        }
+        async function* createIterator() {
+            const task = await withErrorCause(() => nativeFunction(emitResult));
+            try {
+                while (!canceled) {
+                    if (buffer.length > 0) {
+                        const item = buffer.shift();
+                        if (item.err)
+                            throw item.err;
+                        yield item.value;
+                    }
+                    else {
+                        // eslint-disable-next-line no-loop-func
+                        yield new Promise((resolve, reject) => {
+                            waiting = { resolve, reject };
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                if (e === cancel)
+                    return;
+                if (e instanceof Error) {
+                    throw new TurbopackInternalError(e);
+                }
+                throw e;
+            }
+            finally {
+                if (task) {
+                    binding.rootTaskDispose(task);
+                }
+            }
+        }
+        const iterator = createIterator();
+        iterator.return = async () => {
+            canceled = true;
+            if (waiting)
+                waiting.reject(cancel);
+            return { value: undefined, done: true };
+        };
+        return iterator;
+    }
+    class ProjectImpl {
+        constructor(nativeProject) {
+            this._nativeProject = nativeProject;
+        }
+        async update(options) {
+            await withErrorCause(async () => binding.projectUpdate(this._nativeProject, await rustifyPartialProjectOptions(options)));
+        }
+        async writeAllEntrypointsToDisk() {
+            return await withErrorCause(async () => {
+                const napiEndpoints = (await binding.projectWriteAllEntrypointsToDisk(this._nativeProject));
+                return napiEntrypointsToRawEntrypoints(napiEndpoints);
+            });
+        }
+        entrypointsSubscribe() {
+            const subscription = subscribe(false, async (callback) => binding.projectEntrypointsSubscribe(this._nativeProject, callback));
+            return (async function* () {
+                for await (const entrypoints of subscription) {
+                    yield napiEntrypointsToRawEntrypoints(entrypoints);
+                }
+            })();
+        }
+        hmrEvents(identifier) {
+            return subscribe(true, async (callback) => binding.projectHmrEvents(this._nativeProject, identifier, callback));
+        }
+        hmrIdentifiersSubscribe() {
+            return subscribe(false, async (callback) => binding.projectHmrIdentifiersSubscribe(this._nativeProject, callback));
+        }
+        traceSource(stackFrame, currentDirectoryFileUrl) {
+            return binding.projectTraceSource(this._nativeProject, stackFrame, currentDirectoryFileUrl);
+        }
+        getSourceForAsset(filePath) {
+            return binding.projectGetSourceForAsset(this._nativeProject, filePath);
+        }
+        getSourceMap(filePath) {
+            return binding.projectGetSourceMap(this._nativeProject, filePath);
+        }
+        getSourceMapSync(filePath) {
+            return binding.projectGetSourceMapSync(this._nativeProject, filePath);
+        }
+        updateInfoSubscribe(aggregationMs) {
+            return subscribe(true, async (callback) => binding.projectUpdateInfoSubscribe(this._nativeProject, aggregationMs, callback));
+        }
+        shutdown() {
+            return binding.projectShutdown(this._nativeProject);
+        }
+        onExit() {
+            return binding.projectOnExit(this._nativeProject);
+        }
+    }
+    class EndpointImpl {
+        constructor(nativeEndpoint) {
+            this._nativeEndpoint = nativeEndpoint;
+        }
+        async writeToDisk() {
+            return await withErrorCause(() => binding.endpointWriteToDisk(this._nativeEndpoint));
+        }
+        async clientChanged() {
+            const clientSubscription = subscribe(false, async (callback) => binding.endpointClientChangedSubscribe(await this._nativeEndpoint, callback));
+            await clientSubscription.next();
+            return clientSubscription;
+        }
+        async serverChanged(includeIssues) {
+            const serverSubscription = subscribe(false, async (callback) => binding.endpointServerChangedSubscribe(await this._nativeEndpoint, includeIssues, callback));
+            await serverSubscription.next();
+            return serverSubscription;
+        }
+    }
+    function napiEntrypointsToRawEntrypoints(entrypoints) {
+        return {
+            apps: (entrypoints.apps || []).map((e) => new EndpointImpl(e)),
+            libraries: (entrypoints.libraries || []).map((e) => new EndpointImpl(e)),
+            issues: entrypoints.issues,
+            diagnostics: entrypoints.diagnostics,
+        };
+    }
+    return async function createProject(options, turboEngineOptions) {
+        return new ProjectImpl(await binding.projectNew(await rustifyProjectOptions(options), turboEngineOptions || {}));
+    };
+}

package/cjs/types.d.ts

@@ -0,0 +1,261 @@
+import { HmrIdentifiers, NapiIssue, NapiUpdateMessage, NapiWrittenEndpoint, StackFrame } from "./binding";
+export interface BaseUpdate {
+    resource: {
+        headers: unknown;
+        path: string;
+    };
+    diagnostics: unknown[];
+    issues: NapiIssue[];
+}
+export interface IssuesUpdate extends BaseUpdate {
+    type: "issues";
+}
+export interface EcmascriptMergedUpdate {
+    type: "EcmascriptMergedUpdate";
+    chunks: {
+        [moduleName: string]: {
+            type: "partial";
+        };
+    };
+    entries: {
+        [moduleName: string]: {
+            code: string;
+            map: string;
+            url: string;
+        };
+    };
+}
+export interface PartialUpdate extends BaseUpdate {
+    type: "partial";
+    instruction: {
+        type: "ChunkListUpdate";
+        merged: EcmascriptMergedUpdate[] | undefined;
+    };
+}
+export type Update = IssuesUpdate | PartialUpdate;
+export type RustifiedEnv = {
+    name: string;
+    value: string;
+}[];
+export interface EntryOptions {
+    name?: string;
+    import: string;
+    library?: LibraryOptions;
+}
+export interface LibraryOptions {
+    name?: string;
+    export?: Array<string>;
+}
+export interface DefineEnv {
+    client: RustifiedEnv;
+    edge: RustifiedEnv;
+    nodejs: RustifiedEnv;
+}
+export interface ExperimentalConfig {
+}
+export type TurbopackRuleConfigItemOrShortcut = TurbopackRuleConfigItem;
+export type TurbopackRuleConfigItem = TurbopackRuleConfigItemOptions | {
+    [condition: string]: TurbopackRuleConfigItem;
+} | false;
+/**
+ * @deprecated Use `TurbopackRuleConfigItem` instead.
+ */
+export type TurbopackLoaderItem = string | {
+    loader: string;
+    options: Record<string, JSONValue>;
+};
+export type TurbopackRuleConfigItemOptions = {
+    loaders: TurbopackLoaderItem[];
+    as?: string;
+};
+export interface ModuleOptions {
+    rules?: Record<string, TurbopackRuleConfigItemOrShortcut>;
+}
+export interface ResolveOptions {
+    alias?: Record<string, string | string[] | Record<string, string | string[]>>;
+    extensions?: string[];
+}
+export type ExternalType = "script" | "commonjs" | "esm" | "global";
+export interface ExternalAdvanced {
+    root: string;
+    type?: ExternalType;
+    script?: string;
+}
+export type ExternalConfig = string | ExternalAdvanced;
+export interface ConfigComplete {
+    entry: EntryOptions[];
+    mode?: "production" | "development";
+    module?: ModuleOptions;
+    resolve?: ResolveOptions;
+    externals?: Record<string, ExternalConfig>;
+    output?: {
+        path?: string;
+        type?: "standalone" | "export";
+        filename?: string;
+        chunkFilename?: string;
+    };
+    target?: string;
+    sourceMaps?: boolean;
+    optimization?: {
+        moduleIds?: "named" | "deterministic";
+        minify?: boolean;
+        treeShaking?: boolean;
+        splitChunks?: Record<"js" | "css", {
+            minChunkSize?: number;
+            maxChunkCountPerGroup?: number;
+            maxMergeChunkSize?: number;
+        }>;
+        modularizeImports?: Record<string, {
+            transform: string | Record<string, string>;
+            preventFullImport?: boolean;
+            skipDefaultConversion?: boolean;
+        }>;
+        packageImports?: string[];
+        transpilePackages?: string[];
+        removeConsole?: boolean | {
+            exclude?: string[];
+        };
+    };
+    define?: Record<string, string>;
+    styles?: {
+        sass?: {
+            implementation?: string;
+            [key: string]: any;
+        };
+        less?: {
+            implementation?: string;
+            [key: string]: any;
+        };
+        styledJsx?: boolean | {
+            useLightningcss?: boolean;
+        };
+        inlineCss?: {
+            insert?: string;
+            injectType: string;
+        };
+        styledComponents?: boolean | StyledComponentsConfig;
+        emotion?: boolean | EmotionConfig;
+    };
+    images?: {
+        inlineLimit?: number;
+    };
+    experimental?: ExperimentalConfig;
+    persistentCaching?: boolean;
+    cacheHandler?: string;
+}
+export interface StyledComponentsConfig {
+    /**
+     * Enabled by default in development, disabled in production to reduce file size,
+     * setting this will override the default for all environments.
+     */
+    displayName?: boolean;
+    topLevelImportPaths?: string[];
+    ssr?: boolean;
+    fileName?: boolean;
+    meaninglessFileNames?: string[];
+    minify?: boolean;
+    transpileTemplateLiterals?: boolean;
+    namespace?: string;
+    pure?: boolean;
+    cssProp?: boolean;
+}
+export interface EmotionConfig {
+    sourceMap?: boolean;
+    autoLabel?: "dev-only" | "always" | "never";
+    labelFormat?: string;
+    importMap?: {
+        [importName: string]: {
+            [exportName: string]: {
+                canonicalImport?: [string, string];
+                styledBaseImport?: [string, string];
+            };
+        };
+    };
+}
+export type JSONValue = string | number | boolean | JSONValue[] | {
+    [k: string]: JSONValue;
+};
+export interface ProjectOptions {
+    /**
+     * A root path from which all files must be nested under. Trying to access
+     * a file outside this root will fail. Think of this as a chroot.
+     */
+    rootPath: string;
+    /**
+     * A path inside the root_path which contains the app/pages directories.
+     */
+    projectPath: string;
+    /**
+     * The utoo pack configs.
+     */
+    config: ConfigComplete;
+    /**
+     * A map of environment variables to use when compiling code.
+     */
+    processEnv: Record<string, string>;
+    processDefineEnv: DefineEnv;
+    /**
+     * Whether to watch the filesystem for file changes.
+     */
+    watch: {
+        enable: boolean;
+        pollIntervalMs?: number;
+    };
+    /**
+     * The mode in which Next.js is running.
+     */
+    dev: boolean;
+    /**
+     * The build id.
+     */
+    buildId: string;
+}
+export interface Project {
+    update(options: Partial<ProjectOptions>): Promise<void>;
+    entrypointsSubscribe(): AsyncIterableIterator<TurbopackResult<RawEntrypoints>>;
+    hmrEvents(identifier: string): AsyncIterableIterator<TurbopackResult<Update>>;
+    hmrIdentifiersSubscribe(): AsyncIterableIterator<TurbopackResult<HmrIdentifiers>>;
+    getSourceForAsset(filePath: string): Promise<string | null>;
+    getSourceMap(filePath: string): Promise<string | null>;
+    getSourceMapSync(filePath: string): string | null;
+    traceSource(stackFrame: StackFrame, currentDirectoryFileUrl: string): Promise<StackFrame | null>;
+    updateInfoSubscribe(aggregationMs: number): AsyncIterableIterator<TurbopackResult<NapiUpdateMessage>>;
+    shutdown(): Promise<void>;
+    onExit(): Promise<void>;
+}
+export interface RawEntrypoints {
+    apps?: Endpoint[];
+    libraries?: Endpoint[];
+}
+export interface Endpoint {
+    /** Write files for the endpoint to disk. */
+    writeToDisk(): Promise<TurbopackResult<NapiWrittenEndpoint>>;
+    /**
+     * Listen to client-side changes to the endpoint.
+     * After clientChanged() has been awaited it will listen to changes.
+     * The async iterator will yield for each change.
+     */
+    clientChanged(): Promise<AsyncIterableIterator<TurbopackResult>>;
+    /**
+     * Listen to server-side changes to the endpoint.
+     * After serverChanged() has been awaited it will listen to changes.
+     * The async iterator will yield for each change.
+     */
+    serverChanged(includeIssues: boolean): Promise<AsyncIterableIterator<TurbopackResult>>;
+}
+export type StyledString = {
+    type: "text";
+    value: string;
+} | {
+    type: "code";
+    value: string;
+} | {
+    type: "strong";
+    value: string;
+} | {
+    type: "stack";
+    value: StyledString[];
+} | {
+    type: "line";
+    value: StyledString[];
+};

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/util.d.ts

@@ -0,0 +1,10 @@
+import { NapiIssue } from "./binding";
+import { StyledString } from "./types";
+export declare class ModuleBuildError extends Error {
+    name: string;
+}
+export declare function processIssues(result: TurbopackResult, throwIssue: boolean, logErrors: boolean): void;
+export declare function isWellKnownError(issue: NapiIssue): boolean;
+export declare function formatIssue(issue: NapiIssue): string;
+export declare function renderStyledStringToErrorAnsi(string: StyledString): string;
+export declare function isRelevantWarning(issue: NapiIssue): boolean;