@fusionkit/cli 0.1.1 → 0.1.3

package/scope/node_modules/next/dist/lib/metadata/is-metadata-route.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    DEFAULT_METADATA_ROUTE_EXTENSIONS: null,
+    STATIC_METADATA_IMAGES: null,
+    getExtensionRegexString: null,
+    isMetadataPage: null,
+    isMetadataRoute: null,
+    isMetadataRouteFile: null,
+    isStaticMetadataRoute: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DEFAULT_METADATA_ROUTE_EXTENSIONS: function() {
+        return DEFAULT_METADATA_ROUTE_EXTENSIONS;
+    },
+    STATIC_METADATA_IMAGES: function() {
+        return STATIC_METADATA_IMAGES;
+    },
+    getExtensionRegexString: function() {
+        return getExtensionRegexString;
+    },
+    isMetadataPage: function() {
+        return isMetadataPage;
+    },
+    isMetadataRoute: function() {
+        return isMetadataRoute;
+    },
+    isMetadataRouteFile: function() {
+        return isMetadataRouteFile;
+    },
+    isStaticMetadataRoute: function() {
+        return isStaticMetadataRoute;
+    }
+});
+const _normalizepathsep = require("../../shared/lib/page-path/normalize-path-sep");
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _isapprouteroute = require("../is-app-route-route");
+const STATIC_METADATA_IMAGES = {
+    icon: {
+        filename: 'icon',
+        extensions: [
+            'ico',
+            'jpg',
+            'jpeg',
+            'png',
+            'svg'
+        ]
+    },
+    apple: {
+        filename: 'apple-icon',
+        extensions: [
+            'jpg',
+            'jpeg',
+            'png'
+        ]
+    },
+    favicon: {
+        filename: 'favicon',
+        extensions: [
+            'ico'
+        ]
+    },
+    openGraph: {
+        filename: 'opengraph-image',
+        extensions: [
+            'jpg',
+            'jpeg',
+            'png',
+            'gif'
+        ]
+    },
+    twitter: {
+        filename: 'twitter-image',
+        extensions: [
+            'jpg',
+            'jpeg',
+            'png',
+            'gif'
+        ]
+    }
+};
+const DEFAULT_METADATA_ROUTE_EXTENSIONS = [
+    'js',
+    'jsx',
+    'ts',
+    'tsx'
+];
+const getExtensionRegexString = (staticExtensions, dynamicExtensions)=>{
+    // If there's no possible multi dynamic routes, will not match any <name>[].<ext> files
+    if (!dynamicExtensions || dynamicExtensions.length === 0) {
+        return `(\\.(?:${staticExtensions.join('|')}))`;
+    }
+    return `(?:\\.(${staticExtensions.join('|')})|(\\.(${dynamicExtensions.join('|')})))`;
+};
+function isMetadataRouteFile(appDirRelativePath, pageExtensions, strictlyMatchExtensions) {
+    // End with the extension or optional to have the extension
+    // When strictlyMatchExtensions is true, it's used for match file path;
+    // When strictlyMatchExtensions, the dynamic extension is skipped but
+    // static extension is kept, which is usually used for matching route path.
+    const trailingMatcher = (strictlyMatchExtensions ? '' : '?') + '$';
+    // Match the optional variants like /opengraph-image2, /icon-a102f4.png, etc.
+    const variantsMatcher = '\\d?';
+    // The -\w{6} is the suffix that normalized from group routes;
+    const groupSuffix = strictlyMatchExtensions ? '' : '(-\\w{6})?';
+    const suffixMatcher = `${variantsMatcher}${groupSuffix}`;
+    const metadataRouteFilesRegex = [
+        new RegExp(`^[\\\\/]robots${getExtensionRegexString(pageExtensions.concat('txt'), null)}${trailingMatcher}`),
+        new RegExp(`^[\\\\/]manifest${getExtensionRegexString(pageExtensions.concat('webmanifest', 'json'), null)}${trailingMatcher}`),
+        new RegExp(`^[\\\\/]favicon\\.ico$`),
+        new RegExp(`[\\\\/]sitemap${getExtensionRegexString([
+            'xml'
+        ], pageExtensions)}${trailingMatcher}`),
+        new RegExp(`[\\\\/]${STATIC_METADATA_IMAGES.icon.filename}${suffixMatcher}${getExtensionRegexString(STATIC_METADATA_IMAGES.icon.extensions, pageExtensions)}${trailingMatcher}`),
+        new RegExp(`[\\\\/]${STATIC_METADATA_IMAGES.apple.filename}${suffixMatcher}${getExtensionRegexString(STATIC_METADATA_IMAGES.apple.extensions, pageExtensions)}${trailingMatcher}`),
+        new RegExp(`[\\\\/]${STATIC_METADATA_IMAGES.openGraph.filename}${suffixMatcher}${getExtensionRegexString(STATIC_METADATA_IMAGES.openGraph.extensions, pageExtensions)}${trailingMatcher}`),
+        new RegExp(`[\\\\/]${STATIC_METADATA_IMAGES.twitter.filename}${suffixMatcher}${getExtensionRegexString(STATIC_METADATA_IMAGES.twitter.extensions, pageExtensions)}${trailingMatcher}`)
+    ];
+    const normalizedAppDirRelativePath = (0, _normalizepathsep.normalizePathSep)(appDirRelativePath);
+    const matched = metadataRouteFilesRegex.some((r)=>r.test(normalizedAppDirRelativePath));
+    return matched;
+}
+function isStaticMetadataRoute(route) {
+    // extract ext with regex
+    const pathname = route.replace(/\/route$/, '');
+    const matched = (0, _isapprouteroute.isAppRouteRoute)(route) && isMetadataRouteFile(pathname, [], true) && // These routes can either be built by static or dynamic entrypoints,
+    // so we assume they're dynamic
+    pathname !== '/robots.txt' && pathname !== '/manifest.webmanifest' && !pathname.endsWith('/sitemap.xml');
+    return matched;
+}
+function isMetadataPage(page) {
+    const matched = !(0, _isapprouteroute.isAppRouteRoute)(page) && isMetadataRouteFile(page, [], false);
+    return matched;
+}
+function isMetadataRoute(route) {
+    let page = (0, _apppaths.normalizeAppPath)(route).replace(/^\/?app\//, '')// Remove the dynamic route id
+    .replace('/[__metadata_id__]', '')// Remove the /route suffix
+    .replace(/\/route$/, '');
+    if (page[0] !== '/') page = '/' + page;
+    const matched = (0, _isapprouteroute.isAppRouteRoute)(route) && isMetadataRouteFile(page, [], false);
+    return matched;
+}
+
+//# sourceMappingURL=is-metadata-route.js.map

package/scope/node_modules/next/dist/lib/metadata/metadata-context.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createMetadataContext", {
+    enumerable: true,
+    get: function() {
+        return createMetadataContext;
+    }
+});
+function createMetadataContext(renderOpts) {
+    return {
+        trailingSlash: renderOpts.trailingSlash,
+        isStaticMetadataRouteFile: false
+    };
+}
+
+//# sourceMappingURL=metadata-context.js.map

package/scope/node_modules/next/dist/lib/multi-file-writer.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MultiFileWriter", {
+    enumerable: true,
+    get: function() {
+        return MultiFileWriter;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("../shared/lib/isomorphic/path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class MultiFileWriter {
+    constructor(/**
+     * The file system methods to use.
+     */ fs){
+        this.fs = fs;
+        this.tasks = [];
+    }
+    /**
+   * Finds or creates a task for a directory.
+   *
+   * @param directory - The directory to find or create a task for.
+   * @returns The task for the directory.
+   */ findOrCreateTask(directory) {
+        // See if this directory already has a task to create it.
+        for (const task of this.tasks){
+            if (task[0] === directory) {
+                return task;
+            }
+        }
+        const promise = this.fs.mkdir(directory);
+        // Attach a catch handler so that it doesn't throw an unhandled promise
+        // rejection warning.
+        promise.catch(()=>{});
+        // Otherwise, create a new task for this directory.
+        const task = [
+            directory,
+            promise,
+            []
+        ];
+        this.tasks.push(task);
+        return task;
+    }
+    /**
+   * Appends a file to the writer to be written after its containing directory
+   * is created. The file writer should be awaited after all the files have been
+   * appended. Any async operation that occurs between appending and awaiting
+   * may cause an unhandled promise rejection warning and potentially crash the
+   * process.
+   *
+   * @param filePath - The path to the file to write.
+   * @param data - The data to write to the file.
+   */ append(filePath, data) {
+        // Find or create a task for the directory that contains the file.
+        const task = this.findOrCreateTask(_path.default.dirname(filePath));
+        const promise = task[1].then(()=>this.fs.writeFile(filePath, data));
+        // Attach a catch handler so that it doesn't throw an unhandled promise
+        // rejection warning.
+        promise.catch(()=>{});
+        // Add the file write to the task AFTER the directory promise has resolved.
+        task[2].push(promise);
+    }
+    /**
+   * Returns a promise that resolves when all the files have been written.
+   */ wait() {
+        return Promise.all(this.tasks.flatMap((task)=>task[2]));
+    }
+}
+
+//# sourceMappingURL=multi-file-writer.js.map

package/scope/node_modules/next/dist/lib/needs-experimental-react.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "needsExperimentalReact", {
+    enumerable: true,
+    get: function() {
+        return needsExperimentalReact;
+    }
+});
+function needsExperimentalReact(config) {
+    const { ppr, taint, viewTransition, routerBFCache } = config.experimental || {};
+    return Boolean(ppr || taint || viewTransition || routerBFCache);
+}
+
+//# sourceMappingURL=needs-experimental-react.js.map

package/scope/node_modules/next/dist/lib/non-nullable.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "nonNullable", {
+    enumerable: true,
+    get: function() {
+        return nonNullable;
+    }
+});
+function nonNullable(value) {
+    return value !== null && value !== undefined;
+}
+
+//# sourceMappingURL=non-nullable.js.map

package/scope/node_modules/next/dist/lib/normalize-path.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizePath", {
+    enumerable: true,
+    get: function() {
+        return normalizePath;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function normalizePath(file) {
+    return _path.default.sep === '\\' ? file.replace(/\\/g, '/') : file;
+}
+
+//# sourceMappingURL=normalize-path.js.map

package/scope/node_modules/next/dist/lib/oxford-comma-list.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getOxfordCommaList", {
+    enumerable: true,
+    get: function() {
+        return getOxfordCommaList;
+    }
+});
+function getOxfordCommaList(items) {
+    return items.map((v, index, { length })=>(index > 0 ? index === length - 1 ? length > 2 ? ', and ' : ' and ' : ', ' : '') + v).join('');
+}
+
+//# sourceMappingURL=oxford-comma-list.js.map

package/scope/node_modules/next/dist/lib/page-types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "PAGE_TYPES", {
+    enumerable: true,
+    get: function() {
+        return PAGE_TYPES;
+    }
+});
+var PAGE_TYPES = /*#__PURE__*/ function(PAGE_TYPES) {
+    PAGE_TYPES["PAGES"] = "pages";
+    PAGE_TYPES["ROOT"] = "root";
+    PAGE_TYPES["APP"] = "app";
+    return PAGE_TYPES;
+}({});
+
+//# sourceMappingURL=page-types.js.map

package/scope/node_modules/next/dist/lib/patch-incorrect-lockfile.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "patchIncorrectLockfile", {
+    enumerable: true,
+    get: function() {
+        return patchIncorrectLockfile;
+    }
+});
+const _fs = require("fs");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/log"));
+const _findup = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/find-up"));
+const _packagejson = /*#__PURE__*/ _interop_require_default(require("next/package.json"));
+const _ciinfo = require("../server/ci-info");
+const _getregistry = require("./helpers/get-registry");
+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;
+}
+let registry;
+async function fetchPkgInfo(pkg) {
+    if (!registry) registry = (0, _getregistry.getRegistry)();
+    const res = await fetch(`${registry}${pkg}`);
+    if (!res.ok) {
+        throw Object.defineProperty(new Error(`Failed to fetch registry info for ${pkg}, got status ${res.status}`), "__NEXT_ERROR_CODE", {
+            value: "E172",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const data = await res.json();
+    const versionData = data.versions[_packagejson.default.version];
+    return {
+        os: versionData.os,
+        cpu: versionData.cpu,
+        engines: versionData.engines,
+        tarball: versionData.dist.tarball,
+        integrity: versionData.dist.integrity
+    };
+}
+async function patchIncorrectLockfile(dir) {
+    if (process.env.NEXT_IGNORE_INCORRECT_LOCKFILE) {
+        return;
+    }
+    const lockfilePath = await (0, _findup.default)('package-lock.json', {
+        cwd: dir
+    });
+    if (!lockfilePath) {
+        // if no lockfile present there is no action to take
+        return;
+    }
+    const content = await _fs.promises.readFile(lockfilePath, 'utf8');
+    // maintain current line ending
+    const endingNewline = content.endsWith('\r\n') ? '\r\n' : content.endsWith('\n') ? '\n' : '';
+    const lockfileParsed = JSON.parse(content);
+    const lockfileVersion = parseInt(lockfileParsed == null ? void 0 : lockfileParsed.lockfileVersion, 10);
+    const expectedSwcPkgs = Object.keys(_packagejson.default['optionalDependencies'] || {}).filter((pkg)=>pkg.startsWith('@next/swc-'));
+    const patchDependency = (pkg, pkgData)=>{
+        lockfileParsed.dependencies[pkg] = {
+            version: _packagejson.default.version,
+            resolved: pkgData.tarball,
+            integrity: pkgData.integrity,
+            optional: true
+        };
+    };
+    const patchPackage = (pkg, pkgData)=>{
+        lockfileParsed.packages[pkg] = {
+            version: _packagejson.default.version,
+            resolved: pkgData.tarball,
+            integrity: pkgData.integrity,
+            cpu: pkgData.cpu,
+            optional: true,
+            os: pkgData.os,
+            engines: pkgData.engines
+        };
+    };
+    try {
+        const supportedVersions = [
+            1,
+            2,
+            3
+        ];
+        if (!supportedVersions.includes(lockfileVersion)) {
+            // bail on unsupported version
+            return;
+        }
+        // v1 only uses dependencies
+        // v2 uses dependencies and packages
+        // v3 only uses packages
+        const shouldPatchDependencies = lockfileVersion === 1 || lockfileVersion === 2;
+        const shouldPatchPackages = lockfileVersion === 2 || lockfileVersion === 3;
+        if (shouldPatchDependencies && !lockfileParsed.dependencies || shouldPatchPackages && !lockfileParsed.packages) {
+            // invalid lockfile so bail
+            return;
+        }
+        const missingSwcPkgs = [];
+        let pkgPrefix;
+        if (shouldPatchPackages) {
+            pkgPrefix = '';
+            for (const pkg of Object.keys(lockfileParsed.packages)){
+                if (pkg.endsWith('node_modules/next')) {
+                    pkgPrefix = pkg.substring(0, pkg.length - 4);
+                }
+            }
+            if (!pkgPrefix) {
+                // unable to locate the next package so bail
+                return;
+            }
+        }
+        for (const pkg of expectedSwcPkgs){
+            if (shouldPatchDependencies && !lockfileParsed.dependencies[pkg] || shouldPatchPackages && !lockfileParsed.packages[`${pkgPrefix}${pkg}`]) {
+                missingSwcPkgs.push(pkg);
+            }
+        }
+        if (missingSwcPkgs.length === 0) {
+            return;
+        }
+        _log.warn(`Found lockfile missing swc dependencies,`, _ciinfo.isCI ? 'run next locally to automatically patch' : 'patching...');
+        if (_ciinfo.isCI) {
+            // no point in updating in CI as the user can't save the patch
+            return;
+        }
+        const pkgsData = await Promise.all(missingSwcPkgs.map((pkg)=>fetchPkgInfo(pkg)));
+        for(let i = 0; i < pkgsData.length; i++){
+            const pkg = missingSwcPkgs[i];
+            const pkgData = pkgsData[i];
+            if (shouldPatchDependencies) {
+                patchDependency(pkg, pkgData);
+            }
+            if (shouldPatchPackages) {
+                patchPackage(`${pkgPrefix}${pkg}`, pkgData);
+            }
+        }
+        await _fs.promises.writeFile(lockfilePath, JSON.stringify(lockfileParsed, null, 2) + endingNewline);
+        _log.warn('Lockfile was successfully patched, please run "npm install" to ensure @next/swc dependencies are downloaded');
+    } catch (err) {
+        _log.error(`Failed to patch lockfile, please try uninstalling and reinstalling next in this workspace`);
+        console.error(err);
+    }
+}
+
+//# sourceMappingURL=patch-incorrect-lockfile.js.map

package/scope/node_modules/next/dist/lib/pick.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "pick", {
+    enumerable: true,
+    get: function() {
+        return pick;
+    }
+});
+function pick(obj, keys) {
+    const newObj = {};
+    for (const key of keys){
+        newObj[key] = obj[key];
+    }
+    return newObj;
+}
+
+//# sourceMappingURL=pick.js.map