@nilsr0711/drydock 0.1.5 → 0.1.7

package/.next/standalone/node_modules/.pnpm/next@16.2.9_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/next/dist/server/lib/app-info-log.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getEnvInfo: null,
+    logExperimentalInfo: null,
+    logStartInfo: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getEnvInfo: function() {
+        return getEnvInfo;
+    },
+    logExperimentalInfo: function() {
+        return logExperimentalInfo;
+    },
+    logStartInfo: function() {
+        return logStartInfo;
+    }
+});
+const _env = require("@next/env");
+const _inspector = /*#__PURE__*/ _interop_require_wildcard(require("inspector"));
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
+const _picocolors = require("../../lib/picocolors");
+const _configschema = require("../config-schema");
+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;
+}
+function logStartInfo({ networkUrl, appUrl, envInfo, logBundler }) {
+    let versionSuffix = '';
+    const parts = [];
+    if (logBundler) {
+        if (process.env.TURBOPACK) {
+            parts.push('Turbopack');
+        } else if (process.env.NEXT_RSPACK) {
+            parts.push('Rspack');
+        } else {
+            parts.push('webpack');
+        }
+    }
+    if (parts.length > 0) {
+        versionSuffix = ` (${parts.join(', ')})`;
+    }
+    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.2.9"}`))}${versionSuffix}`);
+    if (appUrl) {
+        _log.bootstrap(`- Local:         ${appUrl}`);
+    }
+    if (networkUrl) {
+        _log.bootstrap(`- Network:       ${networkUrl}`);
+    }
+    const inspectorUrl = _inspector.url();
+    if (inspectorUrl) {
+        // Could also parse this port from the inspector URL.
+        // process.debugPort will always be defined even if the process is not being inspected.
+        // The full URL seems noisy as far as I can tell.
+        // Node.js will print the full URL anyway.
+        const debugPort = process.debugPort;
+        _log.bootstrap(`- Debugger port: ${debugPort}`);
+    }
+    if (envInfo == null ? void 0 : envInfo.length) _log.bootstrap(`- Environments: ${envInfo.join(', ')}`);
+}
+function logExperimentalInfo({ experimentalFeatures, cacheComponents }) {
+    if (cacheComponents) {
+        _log.bootstrap(`- Cache Components enabled`);
+    }
+    if (experimentalFeatures == null ? void 0 : experimentalFeatures.length) {
+        _log.bootstrap(`- Experiments (use with caution):`);
+        for (const exp of experimentalFeatures){
+            const isValid = Object.prototype.hasOwnProperty.call(_configschema.experimentalSchema, exp.key);
+            if (isValid) {
+                const symbol = typeof exp.value === 'boolean' ? exp.value === true ? (0, _picocolors.bold)('✓') : (0, _picocolors.bold)('⨯') : '·';
+                const suffix = typeof exp.value === 'number' || typeof exp.value === 'string' ? `: ${JSON.stringify(exp.value)}` : '';
+                const reason = exp.reason ? ` (${exp.reason})` : '';
+                _log.bootstrap(`  ${symbol} ${exp.key}${suffix}${reason}`);
+            } else {
+                _log.bootstrap(`  ? ${(0, _picocolors.strikethrough)(exp.key)} (invalid experimental key)`);
+            }
+        }
+    }
+    // New line after the bootstrap info
+    _log.info('');
+}
+function getEnvInfo(dir) {
+    const { loadedEnvFiles } = (0, _env.loadEnvConfig)(dir, true, console, false);
+    return loadedEnvFiles.map((f)=>f.path);
+}
+
+//# sourceMappingURL=app-info-log.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.9_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/next/dist/server/lib/encode-cache-tag.js

@@ -0,0 +1,45 @@
+/**
+ * Percent-encode every character outside printable ASCII so a tag value can be
+ * safely serialized as part of the `x-next-cache-tags` HTTP header.
+ *
+ * Node's `validateHeaderValue` rejects any code unit outside `\t\x20-\x7e`, so
+ * a matched route path or user-supplied tag containing a non-ASCII character
+ * (Hebrew, Arabic, Chinese, emoji, …) would otherwise throw `ERR_INVALID_CHAR`
+ * and crash ISR on every affected request.
+ *
+ * This is applied at the public boundaries — tag construction
+ * (`getImplicitTags`, `validateTags`) and invalidation input (`revalidatePath`,
+ * `revalidateTag`, `updateTag`) — so storage, comparison, and the wire all see
+ * the same canonical ASCII-safe form.
+ *
+ * The character class `[\t\x20-\x7e]` mirrors Node's `validHdrChars` table —
+ * `\t` plus printable ASCII through `~`. Anything outside that is rejected
+ * by `validateHeaderValue`, so we encode runs of those characters and leave
+ * everything else (`,`, `/`, `%`, `[`, `]`, `_`, `-`, `\t`, …) byte-for-byte
+ * unchanged. This preserves the comma-separated header format and the
+ * dynamic-segment markers in derived tags (`_N_T_/[slug]/page`).
+ *
+ * Properties:
+ * - Fast-path: input that already fits the validation class is returned
+ *   unchanged. This makes the encoder idempotent on already-encoded `%xx`
+ *   sequences.
+ * - Matches *runs* of out-of-class code units so surrogate pairs (e.g. an
+ *   emoji) are handed to `encodeURIComponent` as a complete code point — a
+ *   per-code-unit regex would split the pair and throw `URIError`.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "encodeCacheTag", {
+    enumerable: true,
+    get: function() {
+        return encodeCacheTag;
+    }
+});
+const OUT_OF_CLASS_CHAR = /[^\t\x20-\x7e]/;
+const OUT_OF_CLASS_RUN = /[^\t\x20-\x7e]+/g;
+function encodeCacheTag(tag) {
+    return OUT_OF_CLASS_CHAR.test(tag) ? tag.replace(OUT_OF_CLASS_RUN, (run)=>encodeURIComponent(run)) : tag;
+}
+
+//# sourceMappingURL=encode-cache-tag.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.9_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/next/dist/server/lib/implicit-tags.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getImplicitTags", {
+    enumerable: true,
+    get: function() {
+        return getImplicitTags;
+    }
+});
+const _constants = require("../../lib/constants");
+const _handlers = require("../use-cache/handlers");
+const _encodecachetag = require("./encode-cache-tag");
+const _lazyresult = require("./lazy-result");
+const getDerivedTags = (pathname)=>{
+    const derivedTags = [
+        `/layout`
+    ];
+    // we automatically add the current path segments as tags
+    // for revalidatePath handling
+    if (pathname.startsWith('/')) {
+        const pathnameParts = pathname.split('/');
+        for(let i = 1; i < pathnameParts.length + 1; i++){
+            let curPathname = pathnameParts.slice(0, i).join('/');
+            if (curPathname) {
+                // all derived tags other than the page are layout tags
+                if (!curPathname.endsWith('/page') && !curPathname.endsWith('/route')) {
+                    curPathname = `${curPathname}${!curPathname.endsWith('/') ? '/' : ''}layout`;
+                }
+                derivedTags.push(curPathname);
+            }
+        }
+    }
+    return derivedTags;
+};
+/**
+ * Creates a map with lazy results that fetch the expiration value for the given
+ * tags and respective cache kind when they're awaited for the first time.
+ */ function createTagsExpirationsByCacheKind(tags) {
+    const expirationsByCacheKind = new Map();
+    const cacheHandlers = (0, _handlers.getCacheHandlerEntries)();
+    if (cacheHandlers) {
+        for (const [kind, cacheHandler] of cacheHandlers){
+            if ('getExpiration' in cacheHandler) {
+                expirationsByCacheKind.set(kind, (0, _lazyresult.createLazyResult)(async ()=>cacheHandler.getExpiration(tags)));
+            }
+        }
+    }
+    return expirationsByCacheKind;
+}
+async function getImplicitTags(page, pathname, fallbackRouteParams) {
+    const tags = new Set();
+    // Add the derived tags from the page. Encode each tag so a non-ASCII
+    // pathname doesn't trip header validation when written to
+    // `x-next-cache-tags`. Idempotent on already-ASCII input.
+    const derivedTags = getDerivedTags(page);
+    for (let tag of derivedTags){
+        tag = (0, _encodecachetag.encodeCacheTag)(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${tag}`);
+        tags.add(tag);
+    }
+    // Add the tags from the pathname. If the route has unknown params, we don't
+    // want to add the pathname as a tag, as it will be invalid.
+    if (pathname && (!fallbackRouteParams || fallbackRouteParams.size === 0)) {
+        const tag = (0, _encodecachetag.encodeCacheTag)(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${pathname}`);
+        tags.add(tag);
+    }
+    if (tags.has(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/`)) {
+        tags.add(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/index`);
+    }
+    if (tags.has(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/index`)) {
+        tags.add(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/`);
+    }
+    const tagsArray = Array.from(tags);
+    return {
+        tags: tagsArray,
+        expirationsByCacheKind: createTagsExpirationsByCacheKind(tagsArray)
+    };
+}
+
+//# sourceMappingURL=implicit-tags.js.map