@deshlo/nextjs 0.1.0

package/build/src/index.d.ts

@@ -0,0 +1,5 @@
+export { withSourceInspectorWebpack } from "@deshlo/react/webpack";
+export type { SourceInspectorAdapterOptions, WebpackLikeConfig } from "@deshlo/core";
+export { applySourceInspectorTurbopack, createSourceInspectorTurbopackRules, } from "./turbopack";
+export type { LegacyTurboConfig, NextJsLikeConfig, NextTurbopackConfig, NextjsTurbopackOptions, TurbopackLoader, TurbopackRule, TurbopackRules, } from "./turbopack";
+//# sourceMappingURL=index.d.ts.map

package/build/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AACnE,YAAY,EAAE,6BAA6B,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACrF,OAAO,EACL,6BAA6B,EAC7B,mCAAmC,GACpC,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,sBAAsB,EACtB,eAAe,EACf,aAAa,EACb,cAAc,GACf,MAAM,aAAa,CAAC"}

package/build/src/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSourceInspectorTurbopackRules = exports.applySourceInspectorTurbopack = exports.withSourceInspectorWebpack = void 0;
+var webpack_1 = require("@deshlo/react/webpack");
+Object.defineProperty(exports, "withSourceInspectorWebpack", { enumerable: true, get: function () { return webpack_1.withSourceInspectorWebpack; } });
+var turbopack_1 = require("./turbopack");
+Object.defineProperty(exports, "applySourceInspectorTurbopack", { enumerable: true, get: function () { return turbopack_1.applySourceInspectorTurbopack; } });
+Object.defineProperty(exports, "createSourceInspectorTurbopackRules", { enumerable: true, get: function () { return turbopack_1.createSourceInspectorTurbopackRules; } });

package/build/src/overlay.d.ts

@@ -0,0 +1,2 @@
+export { OverlayGate, type OverlayGateProps, type TriggerKey, } from "@deshlo/react/overlay";
+//# sourceMappingURL=overlay.d.ts.map

package/build/src/overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../src/overlay.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,KAAK,gBAAgB,EACrB,KAAK,UAAU,GAChB,MAAM,uBAAuB,CAAC"}

package/build/src/overlay.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverlayGate = void 0;
+var overlay_1 = require("@deshlo/react/overlay");
+Object.defineProperty(exports, "OverlayGate", { enumerable: true, get: function () { return overlay_1.OverlayGate; } });

package/build/src/turbopack.d.ts

@@ -0,0 +1,37 @@
+import { type SourceInspectorAdapterOptions } from "@deshlo/core";
+export interface NextJsLikeConfig {
+    webpack?: (config: any, context: any) => any;
+    turbopack?: NextTurbopackConfig;
+    experimental?: {
+        turbo?: LegacyTurboConfig;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface NextjsTurbopackOptions extends SourceInspectorAdapterOptions {
+    cwd?: string;
+}
+export type TurbopackLoader = string | {
+    loader: string;
+    options?: unknown;
+};
+export interface TurbopackRule {
+    loaders: TurbopackLoader[];
+    as?: string;
+    condition?: unknown;
+}
+export type TurbopackRules = Record<string, TurbopackRule | TurbopackRule[]>;
+export interface NextTurbopackConfig {
+    root?: string;
+    rules?: TurbopackRules;
+    [key: string]: unknown;
+}
+export interface LegacyTurboConfig {
+    root?: string;
+    rules?: TurbopackRules;
+    loaders?: Record<string, TurbopackLoader[]>;
+    [key: string]: unknown;
+}
+export declare function createSourceInspectorTurbopackRules(options?: NextjsTurbopackOptions, cwd?: string, rootDir?: string): TurbopackRules;
+export declare function applySourceInspectorTurbopack<TConfig extends NextJsLikeConfig>(nextConfig: TConfig, options?: NextjsTurbopackOptions): TConfig & NextJsLikeConfig;
+//# sourceMappingURL=turbopack.d.ts.map

package/build/src/turbopack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turbopack.d.ts","sourceRoot":"","sources":["../../src/turbopack.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,6BAA6B,EACnC,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,KAAK,GAAG,CAAC;IAC7C,SAAS,CAAC,EAAE,mBAAmB,CAAC;IAChC,YAAY,CAAC,EAAE;QACb,KAAK,CAAC,EAAE,iBAAiB,CAAC;QAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;IACF,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,sBAAuB,SAAQ,6BAA6B;IAC3E,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAE7E,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa,EAAE,CAAC,CAAC;AAE7E,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC;IAC5C,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AA+GD,wBAAgB,mCAAmC,CACjD,OAAO,GAAE,sBAA2B,EACpC,GAAG,GAAE,MAAqC,EAC1C,OAAO,GAAE,MAA+B,GACvC,cAAc,CAyBhB;AAED,wBAAgB,6BAA6B,CAAC,OAAO,SAAS,gBAAgB,EAC5E,UAAU,EAAE,OAAO,EACnB,OAAO,GAAE,sBAA2B,GACnC,OAAO,GAAG,gBAAgB,CAgE5B"}

package/build/src/turbopack.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSourceInspectorTurbopackRules = createSourceInspectorTurbopackRules;
+exports.applySourceInspectorTurbopack = applySourceInspectorTurbopack;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const core_1 = require("@deshlo/core");
+const TURBOPACK_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx"];
+const SOURCE_INSPECTOR_LOADER = "@deshlo/loader";
+const ROOT_MARKER_FILES = [
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "package-lock.json",
+    "bun.lock",
+    "bun.lockb",
+];
+function toPosixPath(value) {
+    return value.replace(/\\/g, "/");
+}
+function toTurbopackGlob(includePath, rootDir, extension) {
+    const relativePath = toPosixPath(node_path_1.default.relative(rootDir, includePath)).replace(/^\.\/+/, "");
+    if (relativePath.length === 0 || relativePath === ".") {
+        return `*${extension}`;
+    }
+    if (relativePath.startsWith("../")) {
+        return `**/*${extension}`;
+    }
+    return `${relativePath}/**/*${extension}`;
+}
+function findWorkspaceRoot(cwd) {
+    const startDir = node_path_1.default.resolve(cwd);
+    let currentDir = startDir;
+    while (true) {
+        const hasRootMarker = ROOT_MARKER_FILES.some((fileName) => (0, node_fs_1.existsSync)(node_path_1.default.join(currentDir, fileName)));
+        if (hasRootMarker) {
+            return currentDir;
+        }
+        const parentDir = node_path_1.default.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return startDir;
+        }
+        currentDir = parentDir;
+    }
+}
+function normalizeRootPath(rootPath, cwd) {
+    if (typeof rootPath !== "string" || rootPath.trim().length === 0) {
+        return undefined;
+    }
+    return node_path_1.default.resolve(cwd, rootPath);
+}
+function resolveTurbopackRoot(nextConfig, cwd) {
+    const configuredRoot = normalizeRootPath(nextConfig.turbopack?.root, cwd) ??
+        normalizeRootPath(nextConfig.experimental?.turbo?.root, cwd);
+    return configuredRoot ?? findWorkspaceRoot(cwd);
+}
+function mergeRuleEntry(existing, incoming) {
+    if (!existing) {
+        return incoming;
+    }
+    if (Array.isArray(existing)) {
+        return [...existing, incoming];
+    }
+    return [existing, incoming];
+}
+function mergeRules(currentRules, incomingRules) {
+    const merged = {
+        ...(currentRules ?? {}),
+    };
+    for (const [glob, rule] of Object.entries(incomingRules)) {
+        if (Array.isArray(rule)) {
+            for (const ruleEntry of rule) {
+                merged[glob] = mergeRuleEntry(merged[glob], ruleEntry);
+            }
+            continue;
+        }
+        merged[glob] = mergeRuleEntry(merged[glob], rule);
+    }
+    return merged;
+}
+function createLegacyTurboLoaders(options, cwd) {
+    const loaderOptions = (0, core_1.buildSourceInspectorLoaderOptions)(options, cwd);
+    const loader = {
+        loader: SOURCE_INSPECTOR_LOADER,
+        options: loaderOptions,
+    };
+    return TURBOPACK_EXTENSIONS.reduce((acc, extension) => {
+        acc[extension] = [loader];
+        return acc;
+    }, {});
+}
+function createSourceInspectorTurbopackRules(options = {}, cwd = options.cwd ?? process.cwd(), rootDir = findWorkspaceRoot(cwd)) {
+    if (!(0, core_1.isSourceInspectorEnabled)(options)) {
+        return {};
+    }
+    const loaderOptions = (0, core_1.buildSourceInspectorLoaderOptions)(options, cwd);
+    const loader = {
+        loader: SOURCE_INSPECTOR_LOADER,
+        options: loaderOptions,
+    };
+    const rules = {};
+    for (const includePath of loaderOptions.includePaths) {
+        for (const extension of TURBOPACK_EXTENSIONS) {
+            const glob = toTurbopackGlob(includePath, rootDir, extension);
+            const incomingRule = {
+                condition: { not: "foreign" },
+                loaders: [loader],
+                as: "*.js",
+            };
+            rules[glob] = mergeRuleEntry(rules[glob], incomingRule);
+        }
+    }
+    return rules;
+}
+function applySourceInspectorTurbopack(nextConfig, options = {}) {
+    if (!(0, core_1.isSourceInspectorEnabled)(options)) {
+        return nextConfig;
+    }
+    const cwd = options.cwd ?? process.cwd();
+    const resolvedRoot = resolveTurbopackRoot(nextConfig, cwd);
+    const rules = createSourceInspectorTurbopackRules(options, cwd, resolvedRoot);
+    if (Object.keys(rules).length === 0) {
+        return nextConfig;
+    }
+    if (nextConfig.turbopack) {
+        return {
+            ...nextConfig,
+            turbopack: {
+                ...nextConfig.turbopack,
+                root: nextConfig.turbopack.root ?? resolvedRoot,
+                rules: mergeRules(nextConfig.turbopack.rules, rules),
+            },
+        };
+    }
+    if (nextConfig.experimental?.turbo) {
+        const legacyTurbo = nextConfig.experimental.turbo;
+        const hasLegacyLoaders = legacyTurbo &&
+            typeof legacyTurbo === "object" &&
+            "loaders" in legacyTurbo &&
+            typeof legacyTurbo.loaders === "object" &&
+            legacyTurbo.loaders !== null;
+        const mergedTurbo = hasLegacyLoaders
+            ? {
+                ...legacyTurbo,
+                root: legacyTurbo.root ?? resolvedRoot,
+                loaders: {
+                    ...legacyTurbo.loaders,
+                    ...createLegacyTurboLoaders(options, cwd),
+                },
+            }
+            : {
+                ...legacyTurbo,
+                root: legacyTurbo.root ?? resolvedRoot,
+                rules: mergeRules(legacyTurbo.rules, rules),
+            };
+        return {
+            ...nextConfig,
+            experimental: {
+                ...nextConfig.experimental,
+                turbo: mergedTurbo,
+            },
+        };
+    }
+    return {
+        ...nextConfig,
+        turbopack: {
+            root: resolvedRoot,
+            rules,
+        },
+    };
+}

package/build/src/turbopack.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=turbopack.test.d.ts.map

package/build/src/turbopack.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turbopack.test.d.ts","sourceRoot":"","sources":["../../src/turbopack.test.ts"],"names":[],"mappings":""}

package/build/src/turbopack.test.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const vitest_1 = require("vitest");
+const turbopack_1 = require("./turbopack");
+const CWD = "/repo";
+(0, vitest_1.describe)("applySourceInspectorTurbopack", () => {
+    (0, vitest_1.it)("creates turbopack rules when config has no turbopack section", () => {
+        const result = (0, turbopack_1.applySourceInspectorTurbopack)({
+            reactStrictMode: true,
+        }, {
+            enabled: true,
+            include: ["app", "components"],
+            wrapLooseTextNodes: true,
+            annotateLeafNodesOnly: true,
+            cwd: CWD,
+        });
+        (0, vitest_1.expect)(result.turbopack?.rules).toBeDefined();
+        (0, vitest_1.expect)(Object.keys(result.turbopack?.rules ?? {})).toEqual(vitest_1.expect.arrayContaining([
+            "app/**/*.js",
+            "app/**/*.jsx",
+            "app/**/*.ts",
+            "app/**/*.tsx",
+            "components/**/*.js",
+            "components/**/*.jsx",
+            "components/**/*.ts",
+            "components/**/*.tsx",
+        ]));
+        const appRule = result.turbopack?.rules?.["app/**/*.tsx"];
+        const firstRule = Array.isArray(appRule) ? appRule[0] : appRule;
+        const firstLoader = firstRule && firstRule.loaders.length > 0 ? firstRule.loaders[0] : undefined;
+        (0, vitest_1.expect)(firstRule).toMatchObject({
+            as: "*.js",
+            condition: { not: "foreign" },
+        });
+        (0, vitest_1.expect)(firstLoader).toMatchObject({
+            loader: "@deshlo/loader",
+            options: {
+                attributeName: "data-src-loc",
+                wrapLooseTextNodes: true,
+                annotateLeafNodesOnly: true,
+                includePaths: [node_path_1.default.resolve(CWD, "app"), node_path_1.default.resolve(CWD, "components")],
+            },
+        });
+        (0, vitest_1.expect)(result.turbopack?.root).toBe(CWD);
+    });
+    (0, vitest_1.it)("merges into existing turbopack rules", () => {
+        const result = (0, turbopack_1.applySourceInspectorTurbopack)({
+            turbopack: {
+                rules: {
+                    "*.mdx": {
+                        loaders: ["mdx-loader"],
+                        as: "*.js",
+                    },
+                },
+            },
+        }, {
+            enabled: true,
+            include: ["app"],
+            cwd: CWD,
+        });
+        const rules = result.turbopack?.rules;
+        (0, vitest_1.expect)(rules?.["*.mdx"]).toBeDefined();
+        (0, vitest_1.expect)(rules?.["app/**/*.tsx"]).toBeDefined();
+    });
+    (0, vitest_1.it)("merges into legacy experimental turbo config", () => {
+        const result = (0, turbopack_1.applySourceInspectorTurbopack)({
+            experimental: {
+                turbo: {
+                    loaders: {
+                        ".mdx": ["mdx-loader"],
+                    },
+                },
+            },
+        }, {
+            enabled: true,
+            include: ["app"],
+            cwd: CWD,
+        });
+        const loaders = result.experimental?.turbo?.loaders;
+        (0, vitest_1.expect)(loaders?.[".mdx"]).toEqual(["mdx-loader"]);
+        (0, vitest_1.expect)(loaders?.[".tsx"]).toBeDefined();
+        (0, vitest_1.expect)(loaders?.[".tsx"]?.[0]).toMatchObject({
+            loader: "@deshlo/loader",
+        });
+    });
+    (0, vitest_1.it)("does nothing when disabled", () => {
+        const nextConfig = {
+            reactStrictMode: true,
+        };
+        const result = (0, turbopack_1.applySourceInspectorTurbopack)(nextConfig, {
+            enabled: false,
+            include: ["app"],
+            cwd: CWD,
+        });
+        (0, vitest_1.expect)(result).toBe(nextConfig);
+    });
+    (0, vitest_1.it)("builds include globs relative to workspace root in monorepos", () => {
+        const workspaceRoot = "/repo";
+        const appDir = "/repo/apps/next-test-app";
+        const result = (0, turbopack_1.applySourceInspectorTurbopack)({
+            reactStrictMode: true,
+            turbopack: {
+                root: workspaceRoot,
+            },
+        }, {
+            enabled: true,
+            include: ["app"],
+            cwd: appDir,
+        });
+        (0, vitest_1.expect)(result.turbopack?.root).toBe(workspaceRoot);
+        (0, vitest_1.expect)(result.turbopack?.rules?.["apps/next-test-app/app/**/*.tsx"]).toBeDefined();
+    });
+});

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@deshlo/nextjs",
+  "version": "0.1.0",
+  "description": "Next.js source inspector bundler utilities",
+  "main": "build/src/index.js",
+  "module": "build/src/index.js",
+  "types": "build/src/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./build/src/index.d.ts",
+      "require": "./build/src/index.js",
+      "import": "./build/src/index.js"
+    },
+    "./overlay": {
+      "types": "./build/src/overlay.d.ts",
+      "require": "./build/src/overlay.js",
+      "import": "./build/src/overlay.js"
+    }
+  },
+  "files": [
+    "build"
+  ],
+  "scripts": {
+    "clean": "rm -rf build",
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "nextjs",
+    "source-map",
+    "debug",
+    "inspector"
+  ],
+  "author": "Nikos Gerontakis",
+  "license": "MIT",
+  "dependencies": {
+    "@deshlo/core": "0.1.0",
+    "@deshlo/react": "0.1.0"
+  },
+  "peerDependencies": {
+    "next": ">=14",
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.2",
+    "vitest": "^3.2.4"
+  }
+}