@obsfx/trekker 0.1.7 → 0.1.8

package/webapp-dist/vendor/next/dist/build/validate-app-paths.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "validateAppPaths", {
+    enumerable: true,
+    get: function() {
+        return validateAppPaths;
+    }
+});
+const _getsegmentparam = require("../shared/lib/router/utils/get-segment-param");
+const _app = require("../shared/lib/router/routes/app");
+/**
+ * Validates segment parameters for common syntax errors.
+ * Based on validation logic from sorted-routes.ts
+ */ function validateSegmentParam(param, pathname) {
+    // Check for empty parameter names
+    if (param.paramName.length === 0) {
+        throw Object.defineProperty(new Error(`Parameter names cannot be empty in route "${pathname}".`), "__NEXT_ERROR_CODE", {
+            value: "E922",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // Check for three-dot character (…) instead of ...
+    if (param.paramName.includes('…')) {
+        throw Object.defineProperty(new Error(`Detected a three-dot character ('…') in parameter "${param.paramName}" in route "${pathname}". Did you mean ('...')?`), "__NEXT_ERROR_CODE", {
+            value: "E921",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // Check for optional non-catch-all segments (not yet supported)
+    if (param.paramType !== 'optional-catchall' && param.paramName.startsWith('[') && param.paramName.endsWith(']')) {
+        throw Object.defineProperty(new Error(`Optional route parameters are not yet supported ("[${param.paramName}]") in route "${pathname}".`), "__NEXT_ERROR_CODE", {
+            value: "E926",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // Check for extra brackets
+    if (param.paramName.startsWith('[') || param.paramName.endsWith(']')) {
+        throw Object.defineProperty(new Error(`Segment names may not start or end with extra brackets ('${param.paramName}') in route "${pathname}".`), "__NEXT_ERROR_CODE", {
+            value: "E916",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // Check for erroneous periods
+    if (param.paramName.startsWith('.')) {
+        throw Object.defineProperty(new Error(`Segment names may not start with erroneous periods ('${param.paramName}') in route "${pathname}".`), "__NEXT_ERROR_CODE", {
+            value: "E920",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+/**
+ * Validates a Route object for internal consistency.
+ * Checks for duplicate slugs, invalid catch-all placement, and other route errors.
+ * For interception routes, validates both the intercepting and intercepted routes separately.
+ * Returns the validated segment parameters.
+ */ function validateAppRoute(route) {
+    // For interception routes, validate the intercepting and intercepted routes separately
+    // This allows the same parameter name to appear in both parts
+    if ((0, _app.isInterceptionAppRoute)(route)) {
+        validateAppRoute(route.interceptingRoute);
+        validateAppRoute(route.interceptedRoute);
+        return;
+    }
+    // Then validate semantic constraints (duplicates, normalization, positioning)
+    const slugNames = new Set();
+    const normalizedSegments = new Set();
+    let hasCatchAll = false;
+    let hasOptionalCatchAllInPath = false;
+    let catchAllPosition = -1;
+    for(let i = 0; i < route.segments.length; i++){
+        const segment = route.segments[i];
+        // Type narrowing - only process dynamic segments
+        if (segment.type === 'dynamic') {
+            // First, validate syntax
+            validateSegmentParam(segment.param, route.pathname);
+            const properties = (0, _getsegmentparam.getParamProperties)(segment.param.paramType);
+            if (properties.repeat) {
+                if (properties.optional) {
+                    hasOptionalCatchAllInPath = true;
+                } else {
+                    hasCatchAll = true;
+                }
+                catchAllPosition = i;
+            }
+            // Check to see if the parameter name is already in use.
+            if (slugNames.has(segment.param.paramName)) {
+                throw Object.defineProperty(new Error(`You cannot have the same slug name "${segment.param.paramName}" repeat within a single dynamic path in route "${route.pathname}".`), "__NEXT_ERROR_CODE", {
+                    value: "E914",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            // Normalize parameter name for comparison by removing all non-word
+            // characters.
+            const normalizedSegment = segment.param.paramName.replace(/\W/g, '');
+            if (normalizedSegments.has(normalizedSegment)) {
+                const existing = Array.from(slugNames).find((s)=>{
+                    return s.replace(/\W/g, '') === normalizedSegment;
+                });
+                throw Object.defineProperty(new Error(`You cannot have the slug names "${existing}" and "${segment.param.paramName}" differ only by non-word symbols within a single dynamic path in route "${route.pathname}".`), "__NEXT_ERROR_CODE", {
+                    value: "E919",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            slugNames.add(segment.param.paramName);
+            normalizedSegments.add(normalizedSegment);
+        }
+        // Check if catch-all is not at the end
+        if (hasCatchAll && i > catchAllPosition) {
+            throw Object.defineProperty(new Error(`Catch-all must be the last part of the URL in route "${route.pathname}".`), "__NEXT_ERROR_CODE", {
+                value: "E918",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (hasOptionalCatchAllInPath && i > catchAllPosition) {
+            throw Object.defineProperty(new Error(`Optional catch-all must be the last part of the URL in route "${route.pathname}".`), "__NEXT_ERROR_CODE", {
+                value: "E913",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    // Check for both required and optional catch-all
+    if (hasCatchAll && hasOptionalCatchAllInPath) {
+        throw Object.defineProperty(new Error(`You cannot use both a required and optional catch-all route at the same level in route "${route.pathname}".`), "__NEXT_ERROR_CODE", {
+            value: "E911",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+/**
+ * Validates a single path for internal consistency and returns its segment parameters.
+ */ function parseAndValidateAppPath(path) {
+    // Fast parse the route information. We're expecting this to be a normalized
+    // route, so we pass `true` to the `parseAppRoute` function.
+    const route = (0, _app.parseAppRoute)(path, true);
+    // Slow walk the data from the route in order to validate it.
+    validateAppRoute(route);
+    return route;
+}
+/**
+ * Normalizes segments by replacing dynamic segment names with placeholders.
+ * This allows us to compare routes for structural equivalence.
+ * Preserves interception markers so that routes with different markers are not considered ambiguous.
+ *
+ * Examples:
+ * - [slug] -> [*]
+ * - [modalSlug] -> [*]
+ * - [...slug] -> [...*]
+ * - [[...slug]] -> [[...*]]
+ * - (..)test -> (..)test
+ * - (..)[slug] -> (..)[*]
+ */ function normalizeSegments(segments) {
+    return '/' + segments.map((segment)=>{
+        if (segment.type === 'static') {
+            return segment.name;
+        }
+        // Dynamic segment - normalize the parameter name by replacing the
+        // parameter name with a wildcard. The interception marker is already
+        // included in the segment name, so no special handling is needed.
+        return segment.name.replace(segment.param.paramName, '*');
+    }).join('/');
+}
+function validateAppPaths(appPaths) {
+    // First, validate each path individually
+    const paramsByPath = new Map();
+    for (const path of appPaths){
+        paramsByPath.set(path, parseAndValidateAppPath(path));
+    }
+    // Group paths by their normalized structure for ambiguity detection
+    const structureMap = new Map();
+    for (const [path, route] of paramsByPath){
+        // Check if the last segment is an optional catch-all and check to see if
+        // there is a route with the same specificity that conflicts with it.
+        const lastSegment = route.segments[route.segments.length - 1];
+        if ((lastSegment == null ? void 0 : lastSegment.type) === 'dynamic' && lastSegment.param.paramType === 'optional-catchall') {
+            const prefixSegments = route.segments.slice(0, -1);
+            const normalizedPrefix = normalizeSegments(prefixSegments);
+            for (const [appPath, appRoute] of paramsByPath){
+                const normalizedAppPath = normalizeSegments(appRoute.segments);
+                // Special case: root-level optional catch-all
+                // /[[...slug]] has prefix '' which should match '/'
+                if (prefixSegments.length === 0 && appPath === '/') {
+                    throw Object.defineProperty(new Error(`You cannot define a route with the same specificity as an optional catch-all route ("${appPath}" and "/[[...${lastSegment.param.paramName}]]").`), "__NEXT_ERROR_CODE", {
+                        value: "E925",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                // General case: compare normalized structures
+                if (normalizedAppPath === normalizedPrefix) {
+                    throw Object.defineProperty(new Error(`You cannot define a route with the same specificity as an optional catch-all route ("${appPath}" and "${normalizedPrefix}/[[...${lastSegment.param.paramName}]]").`), "__NEXT_ERROR_CODE", {
+                        value: "E917",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+            }
+        }
+        // Normalize the route to get its structure
+        const structure = normalizeSegments(route.segments);
+        // Track which paths map to this structure
+        const existingPaths = structureMap.get(structure) ?? [];
+        existingPaths.push(path);
+        structureMap.set(structure, existingPaths);
+    }
+    // Check for ambiguous routes (different slug names, same structure)
+    const conflicts = [];
+    for (const [structure, paths] of structureMap){
+        if (paths.length > 1) {
+            // Multiple paths map to the same structure - this is ambiguous
+            conflicts.push({
+                paths,
+                normalizedPath: structure
+            });
+        }
+    }
+    if (conflicts.length > 0) {
+        const errorMessages = conflicts.map(({ paths, normalizedPath })=>{
+            const pathsList = paths.map((p)=>`  - ${p}`).join('\n');
+            return `Ambiguous route pattern "${normalizedPath}" matches multiple routes:\n${pathsList}`;
+        });
+        throw Object.defineProperty(new Error(`Ambiguous app routes detected:\n\n${errorMessages.join('\n\n')}\n\n` + `These routes cannot be distinguished from each other when matching URLs. ` + `Please ensure that dynamic segments have unique patterns or use different static segments.`), "__NEXT_ERROR_CODE", {
+            value: "E912",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return Array.from(paramsByPath.values());
+}
+
+//# sourceMappingURL=validate-app-paths.js.map

package/webapp-dist/vendor/next/dist/build/webpack/alias/react-dom-server-experimental.js

@@ -0,0 +1,32 @@
+"use strict";
+const ERROR_MESSAGE = 'Internal Error: do not use legacy react-dom/server APIs. If you encountered this error, please open an issue on the Next.js repo.';
+function error() {
+    throw Object.defineProperty(new Error(ERROR_MESSAGE), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+    });
+}
+var b;
+if (process.env.NEXT_RUNTIME === 'nodejs') {
+    if (process.env.NODE_ENV === 'production') {
+        b = require('next/dist/compiled/react-dom-experimental/cjs/react-dom-server.node.production.js');
+    } else {
+        b = require('next/dist/compiled/react-dom-experimental/cjs/react-dom-server.node.development.js');
+    }
+} else {
+    if (process.env.NODE_ENV === 'production') {
+        b = require('next/dist/compiled/react-dom-experimental/cjs/react-dom-server.edge.production.js');
+    } else {
+        b = require('next/dist/compiled/react-dom-experimental/cjs/react-dom-server.edge.development.js');
+    }
+}
+exports.version = b.version;
+exports.renderToReadableStream = b.renderToReadableStream;
+exports.renderToString = error;
+exports.renderToStaticMarkup = error;
+if (b.resume) {
+    exports.resume = b.resume;
+}
+
+//# sourceMappingURL=react-dom-server-experimental.js.map

package/webapp-dist/vendor/next/dist/build/webpack/alias/react-dom-server.js

@@ -0,0 +1,32 @@
+"use strict";
+const ERROR_MESSAGE = 'Internal Error: do not use legacy react-dom/server APIs. If you encountered this error, please open an issue on the Next.js repo.';
+function error() {
+    throw Object.defineProperty(new Error(ERROR_MESSAGE), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+    });
+}
+var b;
+if (process.env.NEXT_RUNTIME === 'nodejs') {
+    if (process.env.NODE_ENV === 'production') {
+        b = require('next/dist/compiled/react-dom/cjs/react-dom-server.node.production.js');
+    } else {
+        b = require('next/dist/compiled/react-dom/cjs/react-dom-server.node.development.js');
+    }
+} else {
+    if (process.env.NODE_ENV === 'production') {
+        b = require('next/dist/compiled/react-dom/cjs/react-dom-server.edge.production.js');
+    } else {
+        b = require('next/dist/compiled/react-dom/cjs/react-dom-server.edge.development.js');
+    }
+}
+exports.version = b.version;
+exports.renderToReadableStream = b.renderToReadableStream;
+exports.renderToString = error;
+exports.renderToStaticMarkup = error;
+if (b.resume) {
+    exports.resume = b.resume;
+}
+
+//# sourceMappingURL=react-dom-server.js.map

package/webapp-dist/vendor/next/dist/build/webpack/cache-invalidation.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    checkFileSystemCacheInvalidationAndCleanup: null,
+    invalidateFileSystemCache: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    checkFileSystemCacheInvalidationAndCleanup: function() {
+        return checkFileSystemCacheInvalidationAndCleanup;
+    },
+    invalidateFileSystemCache: function() {
+        return invalidateFileSystemCache;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const INVALIDATION_MARKER = '__nextjs_invalidated_cache';
+async function invalidateFileSystemCache(cacheDirectory) {
+    let file;
+    try {
+        // We're just opening it so that `open()` creates the file.
+        file = await _promises.default.open(_nodepath.default.join(cacheDirectory, INVALIDATION_MARKER), 'w');
+    // We don't currently write anything to the file, but we could choose to
+    // later, e.g. a reason for the invalidation.
+    } catch (err) {
+        // it's valid for the cache to not exist at all
+        if (err.code !== 'ENOENT') {
+            throw err;
+        }
+    } finally{
+        file == null ? void 0 : file.close();
+    }
+}
+async function checkFileSystemCacheInvalidationAndCleanup(cacheDirectory) {
+    const invalidated = await _promises.default.access(_nodepath.default.join(cacheDirectory, INVALIDATION_MARKER)).then(()=>true, ()=>false);
+    if (invalidated) {
+        await cleanupFileSystemCache(cacheDirectory);
+    }
+}
+/**
+ * Helper for `checkFileSystemCacheInvalidationAndCleanup`. You can call this to
+ * explicitly clean up a database after running `invalidateFileSystemCache` when
+ * webpack is not running.
+ *
+ * You should not run this if the cache has not yet been invalidated, as this
+ * operation is not atomic and could result in a partially-deleted and corrupted
+ * database.
+ */ async function cleanupFileSystemCache(cacheDirectory) {
+    try {
+        await cleanupFileSystemCacheInner(cacheDirectory);
+    } catch (e) {
+        // generate a user-friendly error message
+        throw Object.defineProperty(new Error(`Unable to remove an invalidated webpack cache. If this issue persists ` + `you can work around it by deleting ${cacheDirectory}`, {
+            cause: e
+        }), "__NEXT_ERROR_CODE", {
+            value: "E710",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+async function cleanupFileSystemCacheInner(cacheDirectory) {
+    const files = await _promises.default.readdir(cacheDirectory);
+    // delete everything except the invalidation marker
+    await Promise.all(files.map((name)=>name !== INVALIDATION_MARKER ? _promises.default.rm(_nodepath.default.join(cacheDirectory, name), {
+            force: true,
+            recursive: true,
+            maxRetries: 2
+        }) : null));
+    // delete the invalidation marker last, once we're sure everything is cleaned
+    // up
+    await _promises.default.rm(_nodepath.default.join(cacheDirectory, INVALIDATION_MARKER), {
+        force: true,
+        maxRetries: 2
+    });
+}
+
+//# sourceMappingURL=cache-invalidation.js.map

package/webapp-dist/vendor/next/dist/build/webpack/config/blocks/base.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "base", {
+    enumerable: true,
+    get: function() {
+        return base;
+    }
+});
+const _lodashcurry = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/lodash.curry"));
+const _constants = require("../../../../shared/lib/constants");
+const _devtoolsignorelistplugin = /*#__PURE__*/ _interop_require_default(require("../../plugins/devtools-ignore-list-plugin"));
+const _evalsourcemapdevtoolplugin = /*#__PURE__*/ _interop_require_default(require("../../plugins/eval-source-map-dev-tool-plugin"));
+const _getrspack = require("../../../../shared/lib/get-rspack");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function shouldIgnorePath(modulePath) {
+    return modulePath.includes('node_modules') || modulePath.endsWith('__nextjs-internal-proxy.cjs') || modulePath.endsWith('__nextjs-internal-proxy.mjs') || // Only relevant for when Next.js is symlinked e.g. in the Next.js monorepo
+    modulePath.includes('next/dist');
+}
+const base = (0, _lodashcurry.default)(function base(ctx, config) {
+    config.mode = ctx.isDevelopment ? 'development' : 'production';
+    config.name = ctx.isServer ? ctx.isEdgeRuntime ? _constants.COMPILER_NAMES.edgeServer : _constants.COMPILER_NAMES.server : _constants.COMPILER_NAMES.client;
+    config.target = !ctx.targetWeb ? 'node18.17' // Same version defined in packages/next/package.json#engines
+     : ctx.isEdgeRuntime ? [
+        'web',
+        'es6'
+    ] : [
+        'web',
+        'es6'
+    ];
+    // https://webpack.js.org/configuration/devtool/#development
+    if (ctx.isDevelopment) {
+        // `eval-source-map` provides full-fidelity source maps for the
+        // original source, including columns and original variable names.
+        // This is desirable so the in-browser debugger can correctly pause
+        // and show scoped variables with their original names.
+        config.devtool = 'eval-source-map';
+    } else {
+        if (ctx.isEdgeRuntime || ctx.isServer && ctx.serverSourceMaps || // Enable browser sourcemaps:
+        ctx.productionBrowserSourceMaps && ctx.isClient) {
+            config.devtool = 'source-map';
+        } else {
+            config.devtool = false;
+        }
+    }
+    if (!config.module) {
+        config.module = {
+            rules: []
+        };
+    }
+    config.plugins ??= [];
+    if (config.devtool === 'source-map' && !process.env.NEXT_RSPACK) {
+        config.plugins.push(new _devtoolsignorelistplugin.default({
+            shouldIgnorePath
+        }));
+    } else if (config.devtool === 'eval-source-map') {
+        // We're using a fork of `eval-source-map`
+        config.devtool = false;
+        if (process.env.NEXT_RSPACK) {
+            var _config_output;
+            config.plugins.push(new ((0, _getrspack.getRspackCore)()).EvalSourceMapDevToolPlugin({
+                moduleFilenameTemplate: (_config_output = config.output) == null ? void 0 : _config_output.devtoolModuleFilenameTemplate
+            }));
+        } else {
+            var _config_output1;
+            config.plugins.push(new _evalsourcemapdevtoolplugin.default({
+                moduleFilenameTemplate: (_config_output1 = config.output) == null ? void 0 : _config_output1.devtoolModuleFilenameTemplate,
+                shouldIgnorePath
+            }));
+        }
+    }
+    // TODO: add codemod for "Should not import the named export" with JSON files
+    // config.module.strictExportPresence = !isWebpack5
+    return config;
+});
+
+//# sourceMappingURL=base.js.map