@codelionapps/unharness 0.0.0-stage → 0.1.1

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/mock-request.js

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    MockedRequest: null,
+    MockedResponse: null,
+    createRequestResponseMocks: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MockedRequest: function() {
+        return MockedRequest;
+    },
+    MockedResponse: function() {
+        return MockedResponse;
+    },
+    createRequestResponseMocks: function() {
+        return createRequestResponseMocks;
+    }
+});
+const _stream = /*#__PURE__*/ _interop_require_default(require("stream"));
+const _utils = require("../web/utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class MockedRequest extends _stream.default.Readable {
+    constructor({ url, headers, method, socket = null, readable }){
+        super(), // This is hardcoded for now, but can be updated to be configurable if needed.
+        this.httpVersion = '1.0', this.httpVersionMajor = 1, this.httpVersionMinor = 0, // If we don't actually have a socket, we'll just use a mock one that
+        // always returns false for the `encrypted` property and undefined for the
+        // `remoteAddress` property.
+        this.socket = new Proxy({}, {
+            get: (_target, prop)=>{
+                if (prop !== 'encrypted' && prop !== 'remoteAddress') {
+                    throw new Error('Method not implemented');
+                }
+                if (prop === 'remoteAddress') return undefined;
+                // For this mock request, always ensure we just respond with the encrypted
+                // set to false to ensure there's no odd leakages.
+                return false;
+            }
+        });
+        this.url = url;
+        this.headers = headers;
+        this.method = method;
+        if (readable) {
+            this.bodyReadable = readable;
+            this.bodyReadable.on('end', ()=>this.emit('end'));
+            this.bodyReadable.on('close', ()=>this.emit('close'));
+        }
+        if (socket) {
+            this.socket = socket;
+        }
+    }
+    get headersDistinct() {
+        const headers = {};
+        for (const [key, value] of Object.entries(this.headers)){
+            if (!value) continue;
+            headers[key] = Array.isArray(value) ? value : [
+                value
+            ];
+        }
+        return headers;
+    }
+    _read(size) {
+        if (this.bodyReadable) {
+            return this.bodyReadable._read(size);
+        } else {
+            this.emit('end');
+            this.emit('close');
+        }
+    }
+    /**
+   * The `connection` property is just an alias for the `socket` property.
+   *
+   * @deprecated — since v13.0.0 - Use socket instead.
+   */ get connection() {
+        return this.socket;
+    }
+    // The following methods are not implemented as they are not used in the
+    // Next.js codebase.
+    get aborted() {
+        throw new Error('Method not implemented');
+    }
+    get complete() {
+        throw new Error('Method not implemented');
+    }
+    get trailers() {
+        throw new Error('Method not implemented');
+    }
+    get trailersDistinct() {
+        throw new Error('Method not implemented');
+    }
+    get rawTrailers() {
+        throw new Error('Method not implemented');
+    }
+    get rawHeaders() {
+        throw new Error('Method not implemented.');
+    }
+    setTimeout() {
+        throw new Error('Method not implemented.');
+    }
+}
+class MockedResponse extends _stream.default.Writable {
+    constructor(res = {}){
+        super(), this.statusMessage = '', this.finished = false, this.headersSent = false, /**
+   * A list of buffers that have been written to the response.
+   *
+   * @internal - used internally by Next.js
+   */ this.buffers = [], this.totalSize = 0;
+        this.statusCode = res.statusCode ?? 200;
+        this.socket = res.socket ?? null;
+        this.headers = res.headers ? (0, _utils.fromNodeOutgoingHttpHeaders)(res.headers) : new Headers();
+        this.maximumResponseBody = res.maximumResponseBody;
+        this.headPromise = new Promise((resolve)=>{
+            this.headPromiseResolve = resolve;
+        });
+        // Attach listeners for the `finish`, `end`, and `error` events to the
+        // `MockedResponse` instance.
+        this.hasStreamed = new Promise((resolve, reject)=>{
+            this.on('finish', ()=>resolve(true));
+            this.on('end', ()=>resolve(true));
+            this.on('error', (err)=>reject(err));
+        }).then((val)=>{
+            this.headPromiseResolve == null ? void 0 : this.headPromiseResolve.call(this);
+            return val;
+        });
+        if (res.resWriter) {
+            this.resWriter = res.resWriter;
+        }
+    }
+    appendHeader(name, value) {
+        const values = Array.isArray(value) ? value : [
+            value
+        ];
+        for (const v of values){
+            this.headers.append(name, v);
+        }
+        return this;
+    }
+    /**
+   * Returns true if the response has been sent, false otherwise.
+   *
+   * @internal - used internally by Next.js
+   */ get isSent() {
+        return this.finished || this.headersSent;
+    }
+    /**
+   * The `connection` property is just an alias for the `socket` property.
+   *
+   * @deprecated — since v13.0.0 - Use socket instead.
+   */ get connection() {
+        return this.socket;
+    }
+    write(chunk) {
+        if (this.resWriter) {
+            return this.resWriter(chunk);
+        }
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        if (this.maximumResponseBody !== undefined) {
+            this.totalSize += buffer.byteLength;
+            if (this.totalSize > this.maximumResponseBody) {
+                const error = new Error(`Response body exceeded maximum size of ${this.maximumResponseBody} bytes`);
+                error.code = 'ERR_MAX_BODY_SIZE_EXCEEDED';
+                this.destroy(error);
+                return true;
+            }
+        }
+        this.buffers.push(buffer);
+        return true;
+    }
+    end() {
+        if (this.destroyed) {
+            return this;
+        }
+        this.finished = true;
+        return super.end(...arguments);
+    }
+    /**
+   * This method is a no-op because the `MockedResponse` instance is not
+   * actually connected to a socket. This method is not specified on the
+   * interface type for `ServerResponse` but is called by Node.js.
+   *
+   * @see https://github.com/nodejs/node/pull/7949
+   */ _implicitHeader() {}
+    _write(chunk, _encoding, callback) {
+        this.write(chunk);
+        // According to Node.js documentation, the callback MUST be invoked to
+        // signal that the write completed successfully. If this callback is not
+        // invoked, the 'finish' event will not be emitted.
+        //
+        // https://nodejs.org/docs/latest-v16.x/api/stream.html#writable_writechunk-encoding-callback
+        //
+        // If the stream was destroyed due to an error, we should propagate it
+        if (this.destroyed && this.errored) {
+            callback(this.errored);
+        } else {
+            callback();
+        }
+    }
+    writeHead(statusCode, statusMessage, headers) {
+        if (!headers && typeof statusMessage !== 'string') {
+            headers = statusMessage;
+        } else if (typeof statusMessage === 'string' && statusMessage.length > 0) {
+            this.statusMessage = statusMessage;
+        }
+        if (headers) {
+            // When headers have been set with response.setHeader(), they will be
+            // merged with any headers passed to response.writeHead(), with the
+            // headers passed to response.writeHead() given precedence.
+            //
+            // https://nodejs.org/api/http.html#responsewriteheadstatuscode-statusmessage-headers
+            //
+            // For this reason, we need to only call `set` to ensure that this will
+            // overwrite any existing headers.
+            if (Array.isArray(headers)) {
+                // headers may be an Array where the keys and values are in the same list.
+                // It is not a list of tuples. So, the even-numbered offsets are key
+                // values, and the odd-numbered offsets are the associated values. The
+                // array is in the same format as request.rawHeaders.
+                for(let i = 0; i < headers.length; i += 2){
+                    // The header key is always a string according to the spec.
+                    this.setHeader(headers[i], headers[i + 1]);
+                }
+            } else {
+                for (const [key, value] of Object.entries(headers)){
+                    // Skip undefined values
+                    if (typeof value === 'undefined') continue;
+                    this.setHeader(key, value);
+                }
+            }
+        }
+        this.statusCode = statusCode;
+        this.headersSent = true;
+        this.headPromiseResolve == null ? void 0 : this.headPromiseResolve.call(this);
+        return this;
+    }
+    hasHeader(name) {
+        return this.headers.has(name);
+    }
+    getHeader(name) {
+        return this.headers.get(name) ?? undefined;
+    }
+    getHeaders() {
+        return (0, _utils.toNodeOutgoingHttpHeaders)(this.headers);
+    }
+    getHeaderNames() {
+        return Array.from(this.headers.keys());
+    }
+    setHeader(name, value) {
+        if (Array.isArray(value)) {
+            // Because `set` here should override any existing values, we need to
+            // delete the existing values before setting the new ones via `append`.
+            this.headers.delete(name);
+            for (const v of value){
+                this.headers.append(name, v);
+            }
+        } else if (typeof value === 'number') {
+            this.headers.set(name, value.toString());
+        } else {
+            this.headers.set(name, value);
+        }
+        return this;
+    }
+    removeHeader(name) {
+        this.headers.delete(name);
+    }
+    flushHeaders() {
+    // This is a no-op because we don't actually have a socket to flush the
+    // headers to.
+    }
+    // The following methods are not implemented as they are not used in the
+    // Next.js codebase.
+    get strictContentLength() {
+        throw new Error('Method not implemented.');
+    }
+    writeEarlyHints() {
+        throw new Error('Method not implemented.');
+    }
+    get req() {
+        throw new Error('Method not implemented.');
+    }
+    assignSocket() {
+        throw new Error('Method not implemented.');
+    }
+    detachSocket() {
+        throw new Error('Method not implemented.');
+    }
+    writeContinue() {
+        throw new Error('Method not implemented.');
+    }
+    writeProcessing() {
+        throw new Error('Method not implemented.');
+    }
+    get upgrading() {
+        throw new Error('Method not implemented.');
+    }
+    get chunkedEncoding() {
+        throw new Error('Method not implemented.');
+    }
+    get shouldKeepAlive() {
+        throw new Error('Method not implemented.');
+    }
+    get useChunkedEncodingByDefault() {
+        throw new Error('Method not implemented.');
+    }
+    get sendDate() {
+        throw new Error('Method not implemented.');
+    }
+    setTimeout() {
+        throw new Error('Method not implemented.');
+    }
+    addTrailers() {
+        throw new Error('Method not implemented.');
+    }
+    setHeaders() {
+        throw new Error('Method not implemented.');
+    }
+}
+function createRequestResponseMocks({ url, headers = {}, method = 'GET', bodyReadable, resWriter, socket = null, maximumResponseBody }) {
+    return {
+        req: new MockedRequest({
+            url,
+            headers,
+            method,
+            socket,
+            readable: bodyReadable
+        }),
+        res: new MockedResponse({
+            socket,
+            resWriter,
+            maximumResponseBody
+        })
+    };
+}
+
+//# sourceMappingURL=mock-request.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/module-loader/module-loader.js

@@ -0,0 +1,8 @@
+/**
+ * Loads a given module for a given ID.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=module-loader.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/module-loader/node-module-loader.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NodeModuleLoader", {
+    enumerable: true,
+    get: function() {
+        return NodeModuleLoader;
+    }
+});
+class NodeModuleLoader {
+    async load(id) {
+        if (process.env.NEXT_RUNTIME !== 'edge') {
+            // Need to `await` to cover the case that route is marked ESM modules by ESM escalation.
+            return await (process.env.NEXT_MINIMAL ? __non_webpack_require__(id) : require(id));
+        }
+        throw new Error('NodeModuleLoader is not supported in edge runtime.');
+    }
+}
+
+//# sourceMappingURL=node-module-loader.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/module-loader/route-module-loader.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RouteModuleLoader", {
+    enumerable: true,
+    get: function() {
+        return RouteModuleLoader;
+    }
+});
+const _nodemoduleloader = require("./node-module-loader");
+class RouteModuleLoader {
+    static async load(id, loader = new _nodemoduleloader.NodeModuleLoader()) {
+        const module = await loader.load(id);
+        if ('routeModule' in module) {
+            return module.routeModule;
+        }
+        throw new Error(`Module "${id}" does not export a routeModule.`);
+    }
+}
+
+//# sourceMappingURL=route-module-loader.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/node-fs-methods.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "nodeFs", {
+    enumerable: true,
+    get: function() {
+        return nodeFs;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _nodecrypto = require("node:crypto");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const nodeFs = {
+    existsSync: _fs.default.existsSync,
+    readFile: _fs.default.promises.readFile,
+    readFileSync: _fs.default.readFileSync,
+    writeFile: (f, d)=>_fs.default.promises.writeFile(f, d),
+    writeFileAtomic: async (f, d)=>{
+        const temporary = `${f}.${(0, _nodecrypto.randomUUID)()}.tmp`;
+        try {
+            await _fs.default.promises.writeFile(temporary, d);
+            await _fs.default.promises.link(temporary, f);
+            return true;
+        } catch (error) {
+            if (error.code === 'EEXIST') return false;
+            throw error;
+        } finally{
+            await _fs.default.promises.unlink(temporary).catch(()=>{});
+        }
+    },
+    mkdir: (dir)=>_fs.default.promises.mkdir(dir, {
+            recursive: true
+        }),
+    stat: (f)=>_fs.default.promises.stat(f)
+};
+
+//# sourceMappingURL=node-fs-methods.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/params-utils.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    allParamsAreRootParams: null,
+    hasFallbackRouteParams: null,
+    isEmptyParams: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    allParamsAreRootParams: function() {
+        return allParamsAreRootParams;
+    },
+    hasFallbackRouteParams: function() {
+        return hasFallbackRouteParams;
+    },
+    isEmptyParams: function() {
+        return isEmptyParams;
+    }
+});
+function allParamsAreRootParams(underlyingParams, rootParams) {
+    for(const paramName in underlyingParams){
+        if (!Object.hasOwn(rootParams, paramName)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isEmptyParams(params) {
+    for(const _paramKey in params){
+        return false;
+    }
+    return true;
+}
+function hasFallbackRouteParams(underlyingParams, fallbackParams) {
+    if (fallbackParams) {
+        for(let key in underlyingParams){
+            if (fallbackParams.has(key)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+//# sourceMappingURL=params-utils.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/parse-stack.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseStack", {
+    enumerable: true,
+    get: function() {
+        return parseStack;
+    }
+});
+const _stacktraceparser = require("next/dist/compiled/stacktrace-parser");
+const regexNextStatic = /\/_next(\/static\/.+)/;
+function parseStack(stack, distDir = process.env.__NEXT_DIST_DIR) {
+    if (!stack) return [];
+    // throw away eval information that stacktrace-parser doesn't support
+    // adapted from https://github.com/stacktracejs/error-stack-parser/blob/9f33c224b5d7b607755eb277f9d51fcdb7287e24/error-stack-parser.js#L59C33-L59C62
+    stack = stack.split('\n').map((line)=>{
+        if (line.includes('(eval ')) {
+            line = line.replace(/eval code/g, 'eval').replace(/\(eval at [^()]* \(/, '(file://').replace(/\),.*$/g, ')');
+        }
+        return line;
+    }).join('\n');
+    const frames = (0, _stacktraceparser.parse)(stack);
+    return frames.map((frame)=>{
+        try {
+            const url = new URL(frame.file);
+            const res = regexNextStatic.exec(url.pathname);
+            if (res) {
+                var _distDir_replace;
+                const effectiveDistDir = distDir == null ? void 0 : (_distDir_replace = distDir.replace(/\\/g, '/')) == null ? void 0 : _distDir_replace.replace(/\/$/, '');
+                if (effectiveDistDir) {
+                    frame.file = 'file://' + effectiveDistDir.concat(res.pop()) + url.search;
+                }
+            }
+        } catch  {}
+        return {
+            file: frame.file,
+            line1: frame.lineNumber,
+            column1: frame.column,
+            methodName: frame.methodName,
+            arguments: frame.arguments
+        };
+    });
+}
+
+//# sourceMappingURL=parse-stack.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/patch-fetch-symbol.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NEXT_PATCH_SYMBOL", {
+    enumerable: true,
+    get: function() {
+        return NEXT_PATCH_SYMBOL;
+    }
+});
+const NEXT_PATCH_SYMBOL = Symbol.for('next-patch');
+
+//# sourceMappingURL=patch-fetch-symbol.js.map