@nilsr0711/drydock 0.1.0 → 0.1.2

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/lockfile.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    Lockfile: null,
+    parseDevServerInfo: null,
+    readLockfileContent: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Lockfile: function() {
+        return Lockfile;
+    },
+    parseDevServerInfo: function() {
+        return parseDevServerInfo;
+    },
+    readLockfileContent: function() {
+        return readLockfileContent;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _picocolors = require("../lib/picocolors");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("./output/log"));
+const _swc = require("./swc");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const RETRY_DELAY_MS = 10;
+const MAX_RETRY_MS = 1000;
+function readLockfileContent(lockfilePath) {
+    try {
+        return _fs.default.readFileSync(lockfilePath, 'utf-8');
+    } catch  {
+        return undefined;
+    }
+}
+function parseDevServerInfo(content) {
+    try {
+        return JSON.parse(content);
+    } catch  {
+        return undefined;
+    }
+}
+class Lockfile {
+    constructor(bindings, nativeLockfile){
+        this.bindings = bindings;
+        this.nativeLockfile = nativeLockfile;
+    }
+    /**
+   * Attempts to create or acquire an exclusive lockfile on disk. Lockfiles are
+   * best-effort, depending on the platform.
+   *
+   * - If we fail to acquire the lock, we return `undefined`.
+   * - If we're on wasm, this always returns a dummy `Lockfile` object.
+   *
+   * @param path - Path to the lock file
+   * @param unlockOnExit - Whether to unlock the file on process exit
+   * @param content - Optional content to write to the lockfile (e.g., JSON with server info)
+   */ static tryAcquire(path, unlockOnExit = true, content) {
+        const bindings = (0, _swc.getBindingsSync)();
+        if (bindings.isWasm) {
+            _log.info(`Skipping creating a lockfile at ${(0, _picocolors.cyan)(path)} because we're using WASM bindings`);
+            return new Lockfile(bindings, undefined);
+        } else {
+            let nativeLockfile;
+            try {
+                nativeLockfile = bindings.lockfileTryAcquireSync(path, content);
+            } catch (e) {
+                // this happens if there's an IO error (e.g. `ENOENT`), which is
+                // different than if we just didn't acquire the lock
+                throw Object.defineProperty(new Error('An IO error occurred while attempting to create and acquire the lockfile', {
+                    cause: e
+                }), "__NEXT_ERROR_CODE", {
+                    value: "E859",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            if (nativeLockfile != null) {
+                const jsLockfile = new Lockfile(bindings, nativeLockfile);
+                if (unlockOnExit) {
+                    const exitListener = ()=>{
+                        // Best-Effort: If we don't do this, the operating system will
+                        // release the lock for us. This gives an opportunity to delete the
+                        // unlocked lockfile (which is not otherwise deleted on POSIX).
+                        //
+                        // This must be synchronous because `process.on('exit', ...)` is
+                        // synchronous.
+                        jsLockfile.unlockSync();
+                    };
+                    process.on('exit', exitListener);
+                    jsLockfile.listener = exitListener;
+                }
+                return jsLockfile;
+            } else {
+                return undefined;
+            }
+        }
+    }
+    /**
+   * Attempts to create or acquire a lockfile using `Lockfile.tryAcquire`. If
+   * that returns `undefined`, indicating that another process or caller has the
+   * lockfile, then this will output an error message and exit the process with
+   * a non-zero exit code.
+   *
+   * This will retry a small number of times. This can be useful when running
+   * processes in a loop, e.g. if cleanup isn't fully synchronous due to child
+   * parent/processes.
+   *
+   * @param path - Path to the lock file
+   * @param processName - Name of the process for error messages (e.g., 'next dev')
+   * @param unlockOnExit - Whether to unlock the file on process exit
+   * @param content - Optional content to write to the lockfile (e.g., JSON with server info)
+   * @param projectDir - Optional project directory for enhanced error messages
+   * @param relativeDistDir - Optional relative dist directory path (e.g., '.next/dev')
+   */ static async acquireWithRetriesOrExit(path, processName, unlockOnExit = true, content, projectDir, relativeDistDir) {
+        const startMs = Date.now();
+        let lockfile;
+        while(Date.now() - startMs < MAX_RETRY_MS){
+            lockfile = Lockfile.tryAcquire(path, unlockOnExit, content);
+            if (lockfile !== undefined) break;
+            await new Promise((resolve)=>setTimeout(resolve, RETRY_DELAY_MS));
+        }
+        if (lockfile === undefined) {
+            const isDev = processName === 'next dev';
+            if (isDev) {
+                // For dev server, try to read server info from the lockfile itself
+                const lockfileContent = readLockfileContent(path);
+                const serverInfo = lockfileContent ? parseDevServerInfo(lockfileContent) : undefined;
+                if (serverInfo) {
+                    _log.error(`Another ${(0, _picocolors.cyan)(processName)} server is already running.`);
+                    console.error();
+                    console.error(`- Local:        ${(0, _picocolors.cyan)(serverInfo.appUrl)}`);
+                    console.error(`- PID:          ${serverInfo.pid}`);
+                    if (projectDir) {
+                        console.error(`- Dir:          ${projectDir}`);
+                    }
+                    if (relativeDistDir) {
+                        console.error(`- Log:          ${_path.default.join(relativeDistDir, 'logs', 'next-development.log')}`);
+                    }
+                    console.error();
+                    // Use platform-appropriate kill command
+                    const killCommand = process.platform === 'win32' ? `taskkill /PID ${serverInfo.pid} /F` : `kill ${serverInfo.pid}`;
+                    console.error(`Run ${(0, _picocolors.cyan)(killCommand)} to stop it.`);
+                } else {
+                    // Fallback when we can't read server info from the lockfile
+                    _log.error(`Another ${(0, _picocolors.cyan)(processName)} server is already running in this directory.`);
+                    console.error(`Stop the other server before starting a new one.`);
+                }
+            } else {
+                // For build, show that a build is in progress
+                _log.error(`Another ${(0, _picocolors.cyan)(processName)} process is already running.`);
+                console.error();
+                console.error(`  This could be:`);
+                console.error(`  - A ${(0, _picocolors.cyan)('next build')} still in progress`);
+                console.error(`  - A previous build that didn't exit cleanly`);
+                console.error();
+                _log.info(`${(0, _picocolors.bold)('Suggestion:')} Wait for the build to complete.`);
+            }
+            process.exit(1);
+        }
+        return lockfile;
+    }
+    /**
+   * Releases the lockfile and closes the file descriptor.
+   *
+   * If this is not called, the lock will be released by the operating system
+   * when the file handle is closed during process exit.
+   */ async unlock() {
+        const { nativeLockfile, listener } = this;
+        if (nativeLockfile !== undefined) {
+            await this.bindings.lockfileUnlock(nativeLockfile);
+        }
+        if (listener !== undefined) {
+            process.off('exit', listener);
+        }
+    }
+    /**
+   * A blocking version of `unlock`.
+   */ unlockSync() {
+        const { nativeLockfile, listener } = this;
+        if (nativeLockfile !== undefined) {
+            this.bindings.lockfileUnlockSync(nativeLockfile);
+        }
+        if (listener !== undefined) {
+            process.off('exit', listener);
+        }
+    }
+}
+
+//# sourceMappingURL=lockfile.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/next-dir-paths.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    NEXT_PROJECT_ROOT: null,
+    NEXT_PROJECT_ROOT_DIST: null,
+    NEXT_PROJECT_ROOT_DIST_CLIENT: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NEXT_PROJECT_ROOT: function() {
+        return NEXT_PROJECT_ROOT;
+    },
+    NEXT_PROJECT_ROOT_DIST: function() {
+        return NEXT_PROJECT_ROOT_DIST;
+    },
+    NEXT_PROJECT_ROOT_DIST_CLIENT: function() {
+        return NEXT_PROJECT_ROOT_DIST_CLIENT;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const NEXT_PROJECT_ROOT = _path.default.join(__dirname, '..', '..');
+const NEXT_PROJECT_ROOT_DIST = _path.default.join(NEXT_PROJECT_ROOT, 'dist');
+const NEXT_PROJECT_ROOT_DIST_CLIENT = _path.default.join(NEXT_PROJECT_ROOT_DIST, 'client');
+
+//# sourceMappingURL=next-dir-paths.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/normalize-catchall-routes.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizeCatchAllRoutes", {
+    enumerable: true,
+    get: function() {
+        return normalizeCatchAllRoutes;
+    }
+});
+const _interceptionroutes = require("../shared/lib/router/utils/interception-routes");
+const _apppathnamenormalizer = require("../server/normalizers/built/app/app-pathname-normalizer");
+function normalizeCatchAllRoutes(appPaths, normalizer = new _apppathnamenormalizer.AppPathnameNormalizer()) {
+    const catchAllRoutes = [
+        ...new Set(Object.values(appPaths).flat().filter(isCatchAllRoute)// Sorting is important because we want to match the most specific path.
+        .sort((a, b)=>b.split('/').length - a.split('/').length))
+    ];
+    // interception routes should only be matched by a single entrypoint
+    // we don't want to push a catch-all route to an interception route
+    // because it would mean the interception would be handled by the wrong page component
+    const filteredAppPaths = Object.keys(appPaths).filter((route)=>!(0, _interceptionroutes.isInterceptionRouteAppPath)(route));
+    for (const appPath of filteredAppPaths){
+        for (const catchAllRoute of catchAllRoutes){
+            const normalizedCatchAllRoute = normalizer.normalize(catchAllRoute);
+            const normalizedCatchAllRouteBasePath = normalizedCatchAllRoute.slice(0, normalizedCatchAllRoute.search(catchAllRouteRegex));
+            if (// check if the appPath could match the catch-all
+            appPath.startsWith(normalizedCatchAllRouteBasePath) && // check if there's not already a slot value that could match the catch-all
+            !appPaths[appPath].some((path)=>hasMatchedSlots(path, catchAllRoute))) {
+                // optional catch-all routes are not currently supported, but leaving this logic in place
+                // for when they are eventually supported.
+                if (isOptionalCatchAll(catchAllRoute)) {
+                    // optional catch-all routes should match both the root segment and any segment after it
+                    // for example, `/[[...slug]]` should match `/` and `/foo` and `/foo/bar`
+                    appPaths[appPath].push(catchAllRoute);
+                } else if (isCatchAll(catchAllRoute)) {
+                    // regular catch-all (single bracket) should only match segments after it
+                    // for example, `/[...slug]` should match `/foo` and `/foo/bar` but not `/`
+                    if (normalizedCatchAllRouteBasePath !== appPath) {
+                        appPaths[appPath].push(catchAllRoute);
+                    }
+                }
+            }
+        }
+    }
+}
+function hasMatchedSlots(path1, path2) {
+    const slots1 = path1.split('/').filter(isMatchableSlot);
+    const slots2 = path2.split('/').filter(isMatchableSlot);
+    // if the catch-all route does not have the same number of slots as the app path, it can't match
+    if (slots1.length !== slots2.length) return false;
+    // compare the slots in both paths. For there to be a match, each slot must be the same
+    for(let i = 0; i < slots1.length; i++){
+        if (slots1[i] !== slots2[i]) return false;
+    }
+    return true;
+}
+/**
+ * Returns true for slots that should be considered when checking for match compatibility.
+ * Excludes children slots because these are similar to having a segment-level `page`
+ * which would cause a slot length mismatch when comparing it to a catch-all route.
+ */ function isMatchableSlot(segment) {
+    return segment.startsWith('@') && segment !== '@children';
+}
+const catchAllRouteRegex = /\[?\[\.\.\./;
+function isCatchAllRoute(pathname) {
+    // Optional catch-all slots are not currently supported, and as such they are not considered when checking for match compatability.
+    return !isOptionalCatchAll(pathname) && isCatchAll(pathname);
+}
+function isOptionalCatchAll(pathname) {
+    return pathname.includes('[[...');
+}
+function isCatchAll(pathname) {
+    return pathname.includes('[...');
+}
+
+//# sourceMappingURL=normalize-catchall-routes.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/output/index.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    reportTrigger: null,
+    watchCompilers: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    reportTrigger: function() {
+        return reportTrigger;
+    },
+    watchCompilers: function() {
+        return watchCompilers;
+    }
+});
+const _unistore = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/unistore"));
+const _formatwebpackmessages = /*#__PURE__*/ _interop_require_default(require("../../shared/lib/format-webpack-messages"));
+const _store = require("./store");
+const _constants = require("../../shared/lib/constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const buildStore = (0, _unistore.default)({
+    // @ts-expect-error initial value
+    client: {},
+    // @ts-expect-error initial value
+    server: {},
+    // @ts-expect-error initial value
+    edgeServer: {}
+});
+let buildWasDone = false;
+let clientWasLoading = true;
+let serverWasLoading = true;
+let edgeServerWasLoading = false;
+buildStore.subscribe((state)=>{
+    const { client, server, edgeServer, trigger, url } = state;
+    const { appUrl } = _store.store.getState();
+    if (client.loading || server.loading || (edgeServer == null ? void 0 : edgeServer.loading)) {
+        _store.store.setState({
+            bootstrap: false,
+            appUrl: appUrl,
+            // If it takes more than 3 seconds to compile, mark it as loading status
+            loading: true,
+            trigger,
+            url
+        }, true);
+        clientWasLoading = !buildWasDone && clientWasLoading || client.loading;
+        serverWasLoading = !buildWasDone && serverWasLoading || server.loading;
+        edgeServerWasLoading = !buildWasDone && edgeServerWasLoading || edgeServer.loading;
+        buildWasDone = false;
+        return;
+    }
+    buildWasDone = true;
+    let partialState = {
+        bootstrap: false,
+        appUrl: appUrl,
+        loading: false,
+        typeChecking: false,
+        totalModulesCount: (clientWasLoading ? client.totalModulesCount : 0) + (serverWasLoading ? server.totalModulesCount : 0) + (edgeServerWasLoading ? (edgeServer == null ? void 0 : edgeServer.totalModulesCount) || 0 : 0),
+        hasEdgeServer: !!edgeServer
+    };
+    if (client.errors && clientWasLoading) {
+        // Show only client errors
+        _store.store.setState({
+            ...partialState,
+            errors: client.errors,
+            warnings: null
+        }, true);
+    } else if (server.errors && serverWasLoading) {
+        _store.store.setState({
+            ...partialState,
+            errors: server.errors,
+            warnings: null
+        }, true);
+    } else if (edgeServer.errors && edgeServerWasLoading) {
+        _store.store.setState({
+            ...partialState,
+            errors: edgeServer.errors,
+            warnings: null
+        }, true);
+    } else {
+        // Show warnings from all of them
+        const warnings = [
+            ...client.warnings || [],
+            ...server.warnings || [],
+            ...edgeServer.warnings || []
+        ];
+        _store.store.setState({
+            ...partialState,
+            errors: null,
+            warnings: warnings.length === 0 ? null : warnings
+        }, true);
+    }
+});
+function watchCompilers(client, server, edgeServer) {
+    buildStore.setState({
+        client: {
+            loading: true
+        },
+        server: {
+            loading: true
+        },
+        edgeServer: {
+            loading: true
+        },
+        trigger: 'initial',
+        url: undefined
+    });
+    function tapCompiler(key, compiler, onEvent) {
+        compiler.hooks.invalid.tap(`NextJsInvalid-${key}`, ()=>{
+            onEvent({
+                loading: true
+            });
+        });
+        compiler.hooks.done.tap(`NextJsDone-${key}`, (stats)=>{
+            const { errors, warnings } = (0, _formatwebpackmessages.default)(stats.toJson({
+                preset: 'errors-warnings',
+                moduleTrace: true
+            }));
+            const hasErrors = !!(errors == null ? void 0 : errors.length);
+            const hasWarnings = !!(warnings == null ? void 0 : warnings.length);
+            onEvent({
+                loading: false,
+                totalModulesCount: stats.compilation.modules.size,
+                errors: hasErrors ? errors : null,
+                warnings: hasWarnings ? warnings : null
+            });
+        });
+    }
+    tapCompiler(_constants.COMPILER_NAMES.client, client, (status)=>{
+        if (!status.loading && !buildStore.getState().server.loading && !buildStore.getState().edgeServer.loading && status.totalModulesCount > 0) {
+            buildStore.setState({
+                client: status,
+                trigger: undefined,
+                url: undefined
+            });
+        } else {
+            buildStore.setState({
+                client: status
+            });
+        }
+    });
+    tapCompiler(_constants.COMPILER_NAMES.server, server, (status)=>{
+        if (!status.loading && !buildStore.getState().client.loading && !buildStore.getState().edgeServer.loading && status.totalModulesCount > 0) {
+            buildStore.setState({
+                server: status,
+                trigger: undefined,
+                url: undefined
+            });
+        } else {
+            buildStore.setState({
+                server: status
+            });
+        }
+    });
+    tapCompiler(_constants.COMPILER_NAMES.edgeServer, edgeServer, (status)=>{
+        if (!status.loading && !buildStore.getState().client.loading && !buildStore.getState().server.loading && status.totalModulesCount > 0) {
+            buildStore.setState({
+                edgeServer: status,
+                trigger: undefined,
+                url: undefined
+            });
+        } else {
+            buildStore.setState({
+                edgeServer: status
+            });
+        }
+    });
+}
+function reportTrigger(trigger, url) {
+    buildStore.setState({
+        trigger,
+        url
+    });
+}
+
+//# sourceMappingURL=index.js.map