db-json-cli 2.0.1 → 2.0.2

package/.next/standalone/node_modules/next/dist/lib/fs/rename.js

@@ -0,0 +1,128 @@
+/*
+MIT License
+
+Copyright (c) 2015 - present Microsoft Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */ // This file is based on https://github.com/microsoft/vscode/blob/f860fcf11022f10a992440fd54c6e45674e39617/src/vs/base/node/pfs.ts
+// See the LICENSE at the top of the file
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "rename", {
+    enumerable: true,
+    get: function() {
+        return rename;
+    }
+});
+const _gracefulfs = /*#__PURE__*/ _interop_require_wildcard(require("graceful-fs"));
+const _util = require("util");
+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;
+}
+async function rename(source, target, windowsRetryTimeout = 60000 /* matches graceful-fs */ ) {
+    if (source === target) {
+        return; // simulate node.js behaviour here and do a no-op if paths match
+    }
+    if (process.platform === "win32" && typeof windowsRetryTimeout === "number") {
+        // On Windows, a rename can fail when either source or target
+        // is locked by AV software. We do leverage graceful-fs to iron
+        // out these issues, however in case the target file exists,
+        // graceful-fs will immediately return without retry for fs.rename().
+        await renameWithRetry(source, target, Date.now(), windowsRetryTimeout);
+    } else {
+        await (0, _util.promisify)(_gracefulfs.rename)(source, target);
+    }
+}
+async function renameWithRetry(source, target, startTime, retryTimeout, attempt = 0) {
+    try {
+        return await (0, _util.promisify)(_gracefulfs.rename)(source, target);
+    } catch (error) {
+        if (error.code !== "EACCES" && error.code !== "EPERM" && error.code !== "EBUSY") {
+            throw error // only for errors we think are temporary
+            ;
+        }
+        if (Date.now() - startTime >= retryTimeout) {
+            console.error(`[node.js fs] rename failed after ${attempt} retries with error: ${error}`);
+            throw error // give up after configurable timeout
+            ;
+        }
+        if (attempt === 0) {
+            let abortRetry = false;
+            try {
+                const stat = await (0, _util.promisify)(_gracefulfs.stat)(target);
+                if (!stat.isFile()) {
+                    abortRetry = true // if target is not a file, EPERM error may be raised and we should not attempt to retry
+                    ;
+                }
+            } catch (e) {
+            // Ignore
+            }
+            if (abortRetry) {
+                throw error;
+            }
+        }
+        // Delay with incremental backoff up to 100ms
+        await timeout(Math.min(100, attempt * 10));
+        // Attempt again
+        return renameWithRetry(source, target, startTime, retryTimeout, attempt + 1);
+    }
+}
+const timeout = (millis)=>new Promise((resolve)=>setTimeout(resolve, millis));
+
+//# sourceMappingURL=rename.js.map

package/.next/standalone/node_modules/next/dist/lib/fs/write-atomic.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "writeFileAtomic", {
+    enumerable: true,
+    get: function() {
+        return writeFileAtomic;
+    }
+});
+const _promises = require("fs/promises");
+const _rename = require("./rename");
+async function writeFileAtomic(filePath, content) {
+    const tempPath = filePath + ".tmp." + Math.random().toString(36).slice(2);
+    try {
+        await (0, _promises.writeFile)(tempPath, content, "utf-8");
+        await (0, _rename.rename)(tempPath, filePath);
+    } catch (e) {
+        try {
+            await (0, _promises.unlink)(tempPath);
+        } catch  {
+        // ignore
+        }
+        throw e;
+    }
+}
+
+//# sourceMappingURL=write-atomic.js.map

package/.next/standalone/node_modules/next/dist/lib/generate-interception-routes-rewrites.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    generateInterceptionRoutesRewrites: null,
+    isInterceptionRouteRewrite: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    generateInterceptionRoutesRewrites: function() {
+        return generateInterceptionRoutesRewrites;
+    },
+    isInterceptionRouteRewrite: function() {
+        return isInterceptionRouteRewrite;
+    }
+});
+const _pathtoregexp = require("next/dist/compiled/path-to-regexp");
+const _approuterheaders = require("../client/components/app-router-headers");
+const _interceptionroutes = require("../server/future/helpers/interception-routes");
+// a function that converts normalised paths (e.g. /foo/[bar]/[baz]) to the format expected by pathToRegexp (e.g. /foo/:bar/:baz)
+function toPathToRegexpPath(path) {
+    return path.replace(/\[\[?([^\]]+)\]\]?/g, (_, capture)=>{
+        // handle catch-all segments (e.g. /foo/bar/[...baz] or /foo/bar/[[...baz]])
+        if (capture.startsWith("...")) {
+            return `:${capture.slice(3)}*`;
+        }
+        return ":" + capture;
+    });
+}
+// for interception routes we don't have access to the dynamic segments from the
+// referrer route so we mark them as noop for the app renderer so that it
+// can retrieve them from the router state later on. This also allows us to
+// compile the route properly with path-to-regexp, otherwise it will throw
+function voidParamsBeforeInterceptionMarker(path) {
+    let newPath = [];
+    let foundInterceptionMarker = false;
+    for (const segment of path.split("/")){
+        if (_interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((marker)=>segment.startsWith(marker))) {
+            foundInterceptionMarker = true;
+        }
+        if (segment.startsWith(":") && !foundInterceptionMarker) {
+            newPath.push("__NEXT_EMPTY_PARAM__");
+        } else {
+            newPath.push(segment);
+        }
+    }
+    return newPath.join("/");
+}
+function generateInterceptionRoutesRewrites(appPaths, basePath = "") {
+    const rewrites = [];
+    for (const appPath of appPaths){
+        if ((0, _interceptionroutes.isInterceptionRouteAppPath)(appPath)) {
+            const { interceptingRoute, interceptedRoute } = (0, _interceptionroutes.extractInterceptionRouteInformation)(appPath);
+            const normalizedInterceptingRoute = `${interceptingRoute !== "/" ? toPathToRegexpPath(interceptingRoute) : ""}/(.*)?`;
+            const normalizedInterceptedRoute = toPathToRegexpPath(interceptedRoute);
+            const normalizedAppPath = voidParamsBeforeInterceptionMarker(toPathToRegexpPath(appPath));
+            // pathToRegexp returns a regex that matches the path, but we need to
+            // convert it to a string that can be used in a header value
+            // to the format that Next/the proxy expects
+            let interceptingRouteRegex = (0, _pathtoregexp.pathToRegexp)(normalizedInterceptingRoute).toString().slice(2, -3);
+            rewrites.push({
+                source: `${basePath}${normalizedInterceptedRoute}`,
+                destination: `${basePath}${normalizedAppPath}`,
+                has: [
+                    {
+                        type: "header",
+                        key: _approuterheaders.NEXT_URL,
+                        value: interceptingRouteRegex
+                    }
+                ]
+            });
+        }
+    }
+    return rewrites;
+}
+function isInterceptionRouteRewrite(route) {
+    var _route_has_, _route_has;
+    // When we generate interception rewrites in the above implementation, we always do so with only a single `has` condition.
+    return ((_route_has = route.has) == null ? void 0 : (_route_has_ = _route_has[0]) == null ? void 0 : _route_has_.key) === _approuterheaders.NEXT_URL;
+}
+
+//# sourceMappingURL=generate-interception-routes-rewrites.js.map

package/.next/standalone/node_modules/next/dist/lib/get-project-dir.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getProjectDir", {
+    enumerable: true,
+    get: function() {
+        return getProjectDir;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _log = require("../build/output/log");
+const _detecttypo = require("./detect-typo");
+const _realpath = require("./realpath");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getProjectDir(dir) {
+    try {
+        const resolvedDir = _path.default.resolve(dir || ".");
+        const realDir = (0, _realpath.realpathSync)(resolvedDir);
+        if (resolvedDir !== realDir && resolvedDir.toLowerCase() === realDir.toLowerCase()) {
+            (0, _log.warn)(`Invalid casing detected for project dir, received ${resolvedDir} actual path ${realDir}, see more info here https://nextjs.org/docs/messages/invalid-project-dir-casing`);
+        }
+        return realDir;
+    } catch (err) {
+        if (err.code === "ENOENT") {
+            if (typeof dir === "string") {
+                const detectedTypo = (0, _detecttypo.detectTypo)(dir, [
+                    "build",
+                    "dev",
+                    "info",
+                    "lint",
+                    "start",
+                    "telemetry"
+                ]);
+                if (detectedTypo) {
+                    (0, _log.error)(`"next ${dir}" does not exist. Did you mean "next ${detectedTypo}"?`);
+                    process.exit(1);
+                }
+            }
+            (0, _log.error)(`Invalid project directory provided, no such directory: ${_path.default.resolve(dir || ".")}`);
+            process.exit(1);
+        }
+        throw err;
+    }
+}
+
+//# sourceMappingURL=get-project-dir.js.map

package/.next/standalone/node_modules/next/dist/lib/has-necessary-dependencies.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "hasNecessaryDependencies", {
+    enumerable: true,
+    get: function() {
+        return hasNecessaryDependencies;
+    }
+});
+const _fs = require("fs");
+const _resolvefrom = require("./resolve-from");
+const _path = require("path");
+async function hasNecessaryDependencies(baseDir, requiredPackages) {
+    let resolutions = new Map();
+    const missingPackages = [];
+    await Promise.all(requiredPackages.map(async (p)=>{
+        try {
+            const pkgPath = await _fs.promises.realpath((0, _resolvefrom.resolveFrom)(baseDir, `${p.pkg}/package.json`));
+            const pkgDir = (0, _path.dirname)(pkgPath);
+            if (p.exportsRestrict) {
+                const fileNameToVerify = (0, _path.relative)(p.pkg, p.file);
+                if (fileNameToVerify) {
+                    const fileToVerify = (0, _path.join)(pkgDir, fileNameToVerify);
+                    if ((0, _fs.existsSync)(fileToVerify)) {
+                        resolutions.set(p.pkg, fileToVerify);
+                    } else {
+                        return missingPackages.push(p);
+                    }
+                } else {
+                    resolutions.set(p.pkg, pkgPath);
+                }
+            } else {
+                resolutions.set(p.pkg, (0, _resolvefrom.resolveFrom)(baseDir, p.file));
+            }
+        } catch (_) {
+            return missingPackages.push(p);
+        }
+    }));
+    return {
+        resolved: resolutions,
+        missing: missingPackages
+    };
+}
+
+//# sourceMappingURL=has-necessary-dependencies.js.map

package/.next/standalone/node_modules/next/dist/lib/helpers/get-cache-directory.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getCacheDirectory", {
+    enumerable: true,
+    get: function() {
+        return getCacheDirectory;
+    }
+});
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getCacheDirectory(fileDirectory, envPath) {
+    let result;
+    if (envPath) {
+        result = envPath;
+    } else {
+        let systemCacheDirectory;
+        if (process.platform === "linux") {
+            systemCacheDirectory = process.env.XDG_CACHE_HOME || _path.default.join(_os.default.homedir(), ".cache");
+        } else if (process.platform === "darwin") {
+            systemCacheDirectory = _path.default.join(_os.default.homedir(), "Library", "Caches");
+        } else if (process.platform === "win32") {
+            systemCacheDirectory = process.env.LOCALAPPDATA || _path.default.join(_os.default.homedir(), "AppData", "Local");
+        } else {
+            /// Attempt to use generic tmp location for un-handled platform
+            if (!systemCacheDirectory) {
+                for (const dir of [
+                    _path.default.join(_os.default.homedir(), ".cache"),
+                    _path.default.join(_os.default.tmpdir())
+                ]){
+                    if (_fs.default.existsSync(dir)) {
+                        systemCacheDirectory = dir;
+                        break;
+                    }
+                }
+            }
+            if (!systemCacheDirectory) {
+                console.error(new Error("Unsupported platform: " + process.platform));
+                process.exit(0);
+            }
+        }
+        result = _path.default.join(systemCacheDirectory, fileDirectory);
+    }
+    if (!_path.default.isAbsolute(result)) {
+        // It is important to resolve to the absolute path:
+        //   - for unzipping to work correctly;
+        //   - so that registry directory matches between installation and execution.
+        // INIT_CWD points to the root of `npm/yarn install` and is probably what
+        // the user meant when typing the relative path.
+        result = _path.default.resolve(process.env["INIT_CWD"] || process.cwd(), result);
+    }
+    return result;
+}
+
+//# sourceMappingURL=get-cache-directory.js.map

package/.next/standalone/node_modules/next/dist/lib/helpers/get-online.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getOnline", {
+    enumerable: true,
+    get: function() {
+        return getOnline;
+    }
+});
+const _child_process = require("child_process");
+const _promises = /*#__PURE__*/ _interop_require_default(require("dns/promises"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getProxy() {
+    if (process.env.https_proxy) {
+        return process.env.https_proxy;
+    }
+    try {
+        const httpsProxy = (0, _child_process.execSync)("npm config get https-proxy", {
+            encoding: "utf8"
+        }).trim();
+        return httpsProxy !== "null" ? httpsProxy : undefined;
+    } catch (e) {
+        return;
+    }
+}
+async function getOnline() {
+    try {
+        await _promises.default.lookup("registry.yarnpkg.com");
+        return true;
+    } catch  {
+        const proxy = getProxy();
+        if (!proxy) {
+            return false;
+        }
+        try {
+            const { hostname } = new URL(proxy);
+            await _promises.default.lookup(hostname);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+}
+
+//# sourceMappingURL=get-online.js.map

package/.next/standalone/node_modules/next/dist/lib/helpers/get-pkg-manager.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getPkgManager", {
+    enumerable: true,
+    get: function() {
+        return getPkgManager;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _child_process = require("child_process");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getPkgManager(baseDir) {
+    try {
+        for (const { lockFile, packageManager } of [
+            {
+                lockFile: "yarn.lock",
+                packageManager: "yarn"
+            },
+            {
+                lockFile: "pnpm-lock.yaml",
+                packageManager: "pnpm"
+            },
+            {
+                lockFile: "package-lock.json",
+                packageManager: "npm"
+            }
+        ]){
+            if (_fs.default.existsSync(_path.default.join(baseDir, lockFile))) {
+                return packageManager;
+            }
+        }
+        const userAgent = process.env.npm_config_user_agent;
+        if (userAgent) {
+            if (userAgent.startsWith("yarn")) {
+                return "yarn";
+            } else if (userAgent.startsWith("pnpm")) {
+                return "pnpm";
+            }
+        }
+        try {
+            (0, _child_process.execSync)("yarn --version", {
+                stdio: "ignore"
+            });
+            return "yarn";
+        } catch  {
+            (0, _child_process.execSync)("pnpm --version", {
+                stdio: "ignore"
+            });
+            return "pnpm";
+        }
+    } catch  {
+        return "npm";
+    }
+}
+
+//# sourceMappingURL=get-pkg-manager.js.map

package/.next/standalone/node_modules/next/dist/lib/helpers/get-registry.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getRegistry", {
+    enumerable: true,
+    get: function() {
+        return getRegistry;
+    }
+});
+const _child_process = require("child_process");
+const _getpkgmanager = require("./get-pkg-manager");
+const _utils = require("../../server/lib/utils");
+function getRegistry(baseDir = process.cwd()) {
+    let registry = `https://registry.npmjs.org/`;
+    try {
+        const pkgManager = (0, _getpkgmanager.getPkgManager)(baseDir);
+        const output = (0, _child_process.execSync)(`${pkgManager} config get registry`, {
+            env: {
+                ...process.env,
+                NODE_OPTIONS: (0, _utils.getNodeOptionsWithoutInspect)()
+            }
+        }).toString().trim();
+        if (output.startsWith("http")) {
+            registry = output.endsWith("/") ? output : `${output}/`;
+        }
+    } finally{
+        return registry;
+    }
+}
+
+//# sourceMappingURL=get-registry.js.map

package/.next/standalone/node_modules/next/dist/lib/helpers/install.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "install", {
+    enumerable: true,
+    get: function() {
+        return install;
+    }
+});
+const _picocolors = require("../picocolors");
+const _crossspawn = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/cross-spawn"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function install(root, dependencies, { packageManager, isOnline, devDependencies }) {
+    /**
+   * (p)npm-specific command-line flags.
+   */ const npmFlags = [];
+    /**
+   * Yarn-specific command-line flags.
+   */ const yarnFlags = [];
+    /**
+   * Return a Promise that resolves once the installation is finished.
+   */ return new Promise((resolve, reject)=>{
+        let args;
+        let command = packageManager;
+        const useYarn = packageManager === "yarn";
+        if (dependencies && dependencies.length) {
+            /**
+       * If there are dependencies, run a variation of `{packageManager} add`.
+       */ if (useYarn) {
+                /**
+         * Call `yarn add --exact (--offline)? (-D)? ...`.
+         */ args = [
+                    "add",
+                    "--exact"
+                ];
+                if (!isOnline) args.push("--offline");
+                args.push("--cwd", root);
+                if (devDependencies) args.push("--dev");
+                args.push(...dependencies);
+            } else {
+                /**
+         * Call `(p)npm install [--save|--save-dev] ...`.
+         */ args = [
+                    "install",
+                    "--save-exact"
+                ];
+                args.push(devDependencies ? "--save-dev" : "--save");
+                args.push(...dependencies);
+            }
+        } else {
+            /**
+       * If there are no dependencies, run a variation of `{packageManager}
+       * install`.
+       */ args = [
+                "install"
+            ];
+            if (!isOnline) {
+                console.log((0, _picocolors.yellow)("You appear to be offline."));
+                if (useYarn) {
+                    console.log((0, _picocolors.yellow)("Falling back to the local Yarn cache."));
+                    console.log();
+                    args.push("--offline");
+                } else {
+                    console.log();
+                }
+            }
+        }
+        /**
+     * Add any package manager-specific flags.
+     */ if (useYarn) {
+            args.push(...yarnFlags);
+        } else {
+            args.push(...npmFlags);
+        }
+        /**
+     * Spawn the installation process.
+     */ const child = (0, _crossspawn.default)(command, args, {
+            stdio: "inherit",
+            env: {
+                ...process.env,
+                ADBLOCK: "1",
+                // we set NODE_ENV to development as pnpm skips dev
+                // dependencies when production
+                NODE_ENV: "development",
+                DISABLE_OPENCOLLECTIVE: "1"
+            }
+        });
+        child.on("close", (code)=>{
+            if (code !== 0) {
+                reject({
+                    command: `${command} ${args.join(" ")}`
+                });
+                return;
+            }
+            resolve();
+        });
+    });
+}
+
+//# sourceMappingURL=install.js.map