super-time-tracker-ui 0.1.37 → 0.1.38

package/dist/standalone/node_modules/next/dist/cli/next-info.js

@@ -0,0 +1,480 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "nextInfo", {
+    enumerable: true,
+    get: function() {
+        return nextInfo;
+    }
+});
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _child_process = /*#__PURE__*/ _interop_require_default(require("child_process"));
+const _picocolors = require("../lib/picocolors");
+const _constants = require("../shared/lib/constants");
+const _config = /*#__PURE__*/ _interop_require_default(require("../server/config"));
+const _getregistry = require("../lib/helpers/get-registry");
+const _parseversioninfo = require("../server/dev/parse-version-info");
+const _versionstaleness = require("../next-devtools/shared/version-staleness");
+const _log = require("../build/output/log");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getPackageVersion(packageName) {
+    try {
+        return require(`${packageName}/package.json`).version;
+    } catch  {
+        return 'N/A';
+    }
+}
+async function getNextConfig() {
+    var _config_experimental;
+    const config = await (0, _config.default)(_constants.PHASE_INFO, process.cwd());
+    return {
+        output: config.output ?? 'N/A',
+        experimental: {
+            useWasmBinary: (_config_experimental = config.experimental) == null ? void 0 : _config_experimental.useWasmBinary
+        }
+    };
+}
+/**
+ * Returns the version of the specified binary, by supplying `--version` argument.
+ * N/A if it fails to run the binary.
+ */ function getBinaryVersion(binaryName) {
+    try {
+        return _child_process.default.execFileSync(binaryName, [
+            '--version'
+        ]).toString().trim();
+    } catch  {
+        try {
+            return _child_process.default.execSync(`${binaryName} --version`).toString().trim();
+        } catch  {
+            return 'N/A';
+        }
+    }
+}
+/**
+ * Collect basic next.js installation information and print it to stdout.
+ */ async function printInfo() {
+    const installedRelease = getPackageVersion('next');
+    const nextConfig = await getNextConfig();
+    let stalenessWithTitle = '';
+    let title = '';
+    let versionInfo;
+    try {
+        const registry = (0, _getregistry.getRegistry)();
+        const res = await fetch(`${registry}-/package/next/dist-tags`);
+        const tags = await res.json();
+        versionInfo = (0, _parseversioninfo.parseVersionInfo)({
+            installed: installedRelease,
+            latest: tags.latest,
+            canary: tags.canary
+        });
+        title = (0, _versionstaleness.getStaleness)(versionInfo).title;
+        if (title) {
+            stalenessWithTitle = ` // ${title}`;
+        }
+    } catch (e) {
+        console.warn(`${(0, _picocolors.yellow)((0, _picocolors.bold)('warn'))}  - Failed to fetch latest canary version. (Reason: ${e.message}.)
+      Detected "${installedRelease}". Visit https://github.com/vercel/next.js/releases.
+      Make sure to try the latest canary version (eg.: \`npm install next@canary\`) to confirm the issue still exists before creating a new issue.
+      \nLearn more: ${(0, _picocolors.cyan)('https://nextjs.org/docs/messages/opening-an-issue')}`);
+    }
+    const cpuCores = _os.default.cpus().length;
+    let relevantPackages = `  next: ${installedRelease}${stalenessWithTitle}
+  eslint-config-next: ${getPackageVersion('eslint-config-next')}
+  react: ${getPackageVersion('react')}
+  react-dom: ${getPackageVersion('react-dom')}
+  typescript: ${getPackageVersion('typescript')}`;
+    if (process.env.NEXT_RSPACK) {
+        relevantPackages += `
+  next-rspack: ${getPackageVersion('next-rspack')}`;
+    }
+    console.log(`
+Operating System:
+  Platform: ${_os.default.platform()}
+  Arch: ${_os.default.arch()}
+  Version: ${_os.default.version()}
+  Available memory (MB): ${Math.ceil(_os.default.totalmem() / 1024 / 1024)}
+  Available CPU cores: ${cpuCores > 0 ? cpuCores : 'N/A'}
+Binaries:
+  Node: ${process.versions.node}
+  npm: ${getBinaryVersion('npm')}
+  Yarn: ${getBinaryVersion('yarn')}
+  pnpm: ${getBinaryVersion('pnpm')}
+Relevant Packages:
+${relevantPackages}
+Next.js Config:
+  output: ${nextConfig.output}`);
+    if (versionInfo == null ? void 0 : versionInfo.staleness.startsWith('stale')) {
+        (0, _log.warn)(`${title}
+   Please try the latest canary version (\`npm install next@canary\`) to confirm the issue still exists before creating a new issue.
+   Read more - https://nextjs.org/docs/messages/opening-an-issue`);
+    }
+}
+/**
+ * Using system-installed tools per each platform, trying to read shared dependencies of next-swc.
+ * This is mainly for debugging DLOPEN failure.
+ *
+ * We don't / can't install these tools by ourselves, will skip the check if we can't find them.
+ */ async function runSharedDependencyCheck(tools, skipMessage) {
+    var _getSupportedArchTriples_currentPlatform;
+    const currentPlatform = _os.default.platform();
+    const spawn = require('next/dist/compiled/cross-spawn');
+    const { getSupportedArchTriples } = require('../build/swc');
+    const triples = ((_getSupportedArchTriples_currentPlatform = getSupportedArchTriples()[currentPlatform]) == null ? void 0 : _getSupportedArchTriples_currentPlatform[_os.default.arch()]) ?? [];
+    // First, check if system have a tool installed. We can't install these by our own.
+    const availableTools = [];
+    for (const tool of tools){
+        try {
+            const check = spawn.sync(tool.bin, tool.checkArgs);
+            if (check.status === 0) {
+                availableTools.push(tool);
+            }
+        } catch  {
+        // ignore if existence check fails
+        }
+    }
+    if (availableTools.length === 0) {
+        return {
+            messages: skipMessage,
+            result: 'skipped'
+        };
+    }
+    const outputs = [];
+    let result = 'fail';
+    for (const triple of triples){
+        const triplePkgName = `@next/swc-${triple.platformArchABI}`;
+        let resolved;
+        try {
+            resolved = require.resolve(triplePkgName);
+        } catch (e) {
+            return {
+                messages: 'Cannot find next-swc installation, skipping dependencies check',
+                result: 'skipped'
+            };
+        }
+        for (const tool of availableTools){
+            const proc = spawn(tool.bin, [
+                ...tool.args,
+                resolved
+            ]);
+            outputs.push(`Running ${tool.bin} ------------- `);
+            // Captures output, doesn't matter if it fails or not since we'll forward both to output.
+            const procPromise = new Promise((resolve)=>{
+                proc.stdout.on('data', function(data) {
+                    outputs.push(data);
+                });
+                proc.stderr.on('data', function(data) {
+                    outputs.push(data);
+                });
+                proc.on('close', (c)=>resolve(c));
+            });
+            let code = await procPromise;
+            if (code === 0) {
+                result = 'pass';
+            }
+        }
+    }
+    return {
+        output: outputs.join('\n'),
+        result
+    };
+}
+/**
+ * Collect additional diagnostics information.
+ */ async function printVerboseInfo() {
+    const fs = require('fs');
+    const currentPlatform = _os.default.platform();
+    if (currentPlatform !== 'win32' && currentPlatform !== 'linux' && currentPlatform !== 'darwin') {
+        console.log('Unsupported platform, only win32, linux, darwin are supported.');
+        return;
+    }
+    // List of tasks to run.
+    const tasks = [
+        {
+            title: 'Host system information',
+            scripts: {
+                default: async ()=>{
+                    // Node.js diagnostic report contains basic information, i.e OS version, CPU architecture, etc.
+                    // Only collect few addtional details here.
+                    const isWsl = require('next/dist/compiled/is-wsl');
+                    const ciInfo = require('next/dist/compiled/ci-info');
+                    const isDocker = require('next/dist/compiled/is-docker');
+                    const output = `
+  WSL: ${isWsl}
+  Docker: ${isDocker()}
+  CI: ${ciInfo.isCI ? ciInfo.name || 'unknown' : 'false'}
+`;
+                    return {
+                        output,
+                        result: 'pass'
+                    };
+                }
+            }
+        },
+        {
+            title: 'Next.js installation',
+            scripts: {
+                default: async ()=>{
+                    const installedRelease = getPackageVersion('next');
+                    const nextConfig = await getNextConfig();
+                    const output = `
+  Binaries:
+    Node: ${process.versions.node}
+    npm: ${getBinaryVersion('npm')}
+    Yarn: ${getBinaryVersion('yarn')}
+    pnpm: ${getBinaryVersion('pnpm')}
+  Relevant Packages:
+    next: ${installedRelease}
+    eslint-config-next: ${getPackageVersion('eslint-config-next')}
+    react: ${getPackageVersion('react')}
+    react-dom: ${getPackageVersion('react-dom')}
+    typescript: ${getPackageVersion('typescript')}
+  Next.js Config:
+    output: ${nextConfig.output}
+
+`;
+                    return {
+                        output,
+                        result: 'pass'
+                    };
+                }
+            }
+        },
+        {
+            title: 'Node.js diagnostic report',
+            scripts: {
+                default: async ()=>{
+                    var _process_report;
+                    const report = (_process_report = process.report) == null ? void 0 : _process_report.getReport();
+                    if (!report) {
+                        return {
+                            messages: 'Node.js diagnostic report is not available.',
+                            result: 'fail'
+                        };
+                    }
+                    const { header, javascriptHeap, sharedObjects } = report;
+                    // Delete some fields potentially containing sensitive information.
+                    header == null ? true : delete header.cwd;
+                    header == null ? true : delete header.commandLine;
+                    header == null ? true : delete header.host;
+                    header == null ? true : delete header.cpus;
+                    header == null ? true : delete header.networkInterfaces;
+                    const reportSummary = {
+                        header,
+                        javascriptHeap,
+                        sharedObjects
+                    };
+                    return {
+                        output: JSON.stringify(reportSummary, null, 2),
+                        result: 'pass'
+                    };
+                }
+            }
+        },
+        {
+            title: 'next-swc installation',
+            scripts: {
+                default: async ()=>{
+                    var _platformArchTriples_currentPlatform;
+                    const output = [];
+                    // First, try to load next-swc via loadBindings.
+                    try {
+                        var _nextConfig_experimental;
+                        let nextConfig = await getNextConfig();
+                        const { loadBindings } = require('../build/swc');
+                        const bindings = await loadBindings((_nextConfig_experimental = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental.useWasmBinary);
+                        // Run arbitrary function to verify the bindings are loaded correctly.
+                        const target = bindings.getTargetTriple();
+                        // We think next-swc is installed correctly if getTargetTriple returns.
+                        return {
+                            output: `next-swc is installed correctly for ${target}`,
+                            result: 'pass'
+                        };
+                    } catch (e) {
+                        output.push(`loadBindings() failed: ${e.message}`);
+                    }
+                    const { platformArchTriples } = require('next/dist/compiled/@napi-rs/triples');
+                    const triples = (_platformArchTriples_currentPlatform = platformArchTriples[currentPlatform]) == null ? void 0 : _platformArchTriples_currentPlatform[_os.default.arch()];
+                    if (!triples || triples.length === 0) {
+                        return {
+                            messages: `No target triples found for ${currentPlatform} / ${_os.default.arch()}`,
+                            result: 'fail'
+                        };
+                    }
+                    // Trying to manually resolve corresponding target triples to see if bindings are physically located.
+                    const path = require('path');
+                    let fallbackBindingsDirectory;
+                    try {
+                        const nextPath = path.dirname(require.resolve('next/package.json'));
+                        fallbackBindingsDirectory = path.join(nextPath, 'next-swc-fallback');
+                    } catch (e) {
+                    // Not able to locate next package from current running location, skipping fallback bindings check.
+                    }
+                    const tryResolve = (pkgName)=>{
+                        try {
+                            const resolved = require.resolve(pkgName);
+                            const fileExists = fs.existsSync(resolved);
+                            let loadError;
+                            let loadSuccess;
+                            try {
+                                loadSuccess = !!require(resolved).getTargetTriple();
+                            } catch (e) {
+                                loadError = e.message;
+                            }
+                            output.push(`${pkgName} exists: ${fileExists} for the triple ${loadSuccess}`);
+                            if (loadError) {
+                                output.push(`${pkgName} load failed: ${loadError ?? 'unknown'}`);
+                            }
+                            if (loadSuccess) {
+                                return true;
+                            }
+                        } catch (e) {
+                            output.push(`${pkgName} resolve failed: ${e.message ?? 'unknown'}`);
+                        }
+                        return false;
+                    };
+                    for (const triple of triples){
+                        const triplePkgName = `@next/swc-${triple.platformArchABI}`;
+                        // Check installed optional dependencies. This is the normal way package being installed.
+                        // For the targets have multiple triples (gnu / musl), if any of them loads successfully, we consider as installed.
+                        if (tryResolve(triplePkgName)) {
+                            break;
+                        }
+                        // Check if fallback binaries are installed.
+                        if (!fallbackBindingsDirectory) {
+                            continue;
+                        }
+                        tryResolve(path.join(fallbackBindingsDirectory, triplePkgName));
+                    }
+                    return {
+                        output: output.join('\n'),
+                        result: 'pass'
+                    };
+                }
+            }
+        },
+        {
+            // For the simplicity, we only check the correctly installed optional dependencies -
+            // as this is mainly for checking DLOPEN failure. If user hit MODULE_NOT_FOUND,
+            // expect above next-swc installation would give some hint instead.
+            title: 'next-swc shared object dependencies',
+            scripts: {
+                linux: async ()=>{
+                    const skipMessage = 'This diagnostics uses system-installed tools (ldd) to check next-swc dependencies, but it is not found. Skipping dependencies check.';
+                    return await runSharedDependencyCheck([
+                        {
+                            bin: 'ldd',
+                            checkArgs: [
+                                '--help'
+                            ],
+                            args: [
+                                '--verbose'
+                            ]
+                        }
+                    ], skipMessage);
+                },
+                win32: async ()=>{
+                    const skipMessage = `This diagnostics uses system-installed tools (dumpbin.exe) to check next-swc dependencies, but it was not found in the path. Skipping dependencies check.
+          dumpbin (https://learn.microsoft.com/en-us/cpp/build/reference/dumpbin-reference) is a part of Microsoft VC toolset,
+          can be installed with Windows SDK, Windows Build tools or Visual Studio.
+
+          Please make sure you have one of them installed and dumpbin.exe is in the path.
+          `;
+                    return await runSharedDependencyCheck([
+                        {
+                            bin: 'dumpbin.exe',
+                            checkArgs: [
+                                '/summary'
+                            ],
+                            args: [
+                                '/imports'
+                            ]
+                        }
+                    ], skipMessage);
+                },
+                darwin: async ()=>{
+                    const skipMessage = 'This diagnostics uses system-installed tools (otools, dyld_info) to check next-swc dependencies, but none of them are found. Skipping dependencies check.';
+                    return await runSharedDependencyCheck([
+                        {
+                            bin: 'otool',
+                            checkArgs: [
+                                '--version'
+                            ],
+                            args: [
+                                '-L'
+                            ]
+                        },
+                        {
+                            bin: 'dyld_info',
+                            checkArgs: [],
+                            args: []
+                        }
+                    ], skipMessage);
+                }
+            }
+        }
+    ];
+    // Collected output after running all tasks.
+    const report = [];
+    console.log('\n');
+    for (const task of tasks){
+        if (task.targetPlatform && task.targetPlatform !== currentPlatform) {
+            report.push({
+                title: task.title,
+                result: {
+                    messages: undefined,
+                    output: `[SKIPPED (${_os.default.platform()} / ${task.targetPlatform})] ${task.title}`,
+                    result: 'skipped'
+                }
+            });
+            continue;
+        }
+        const taskScript = task.scripts[currentPlatform] ?? task.scripts.default;
+        let taskResult;
+        try {
+            taskResult = await taskScript();
+        } catch (e) {
+            taskResult = {
+                messages: `Unexpected failure while running diagnostics: ${e.message}`,
+                result: 'fail'
+            };
+        }
+        console.log(`- ${task.title}: ${taskResult.result}`);
+        if (taskResult.messages) {
+            console.log(`  ${taskResult.messages}`);
+        }
+        report.push({
+            title: task.title,
+            result: taskResult
+        });
+    }
+    console.log(`\n${(0, _picocolors.bold)('Generated diagnostics report')}`);
+    console.log(`\nPlease copy below report and paste it into your issue.`);
+    for (const { title, result } of report){
+        console.log(`\n### ${title}`);
+        if (result.messages) {
+            console.log(result.messages);
+        }
+        if (result.output) {
+            console.log(result.output);
+        }
+    }
+}
+/**
+ * Runs few scripts to collect system information to help with debugging next.js installation issues.
+ * There are 2 modes, by default it collects basic next.js installation with runtime information. If
+ * `--verbose` mode is enabled it'll try to collect, verify more data for next-swc installation and others.
+ */ const nextInfo = async (options)=>{
+    if (options.verbose) {
+        await printVerboseInfo();
+    } else {
+        await printInfo();
+    }
+};
+
+//# sourceMappingURL=next-info.js.map

package/dist/standalone/node_modules/next/dist/cli/next-start.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "nextStart", {
+    enumerable: true,
+    get: function() {
+        return nextStart;
+    }
+});
+const _cpuprofile = require("../server/lib/cpu-profile");
+const _startserver = require("../server/lib/start-server");
+const _utils = require("../server/lib/utils");
+const _getprojectdir = require("../lib/get-project-dir");
+const _getreservedport = require("../lib/helpers/get-reserved-port");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/log"));
+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;
+}
+// Ensure NEXT_PRIVATE_START_TIME is set for accurate "Ready in" timing.
+// This should already be set by bin/next.ts, but we set it here as a fallback
+// in case the module is loaded through a different code path.
+if (!process.env.NEXT_PRIVATE_START_TIME) {
+    process.env.NEXT_PRIVATE_START_TIME = Date.now().toString();
+}
+/**
+ * Start the Next.js server
+ *
+ * @param options The options for the start command
+ * @param directory The directory to start the server in
+ */ const nextStart = async (options, directory)=>{
+    const dir = (0, _getprojectdir.getProjectDir)(directory);
+    const hostname = options.hostname;
+    const inspect = options.inspect;
+    const port = options.port;
+    const keepAliveTimeout = options.keepAliveTimeout;
+    if ((0, _getreservedport.isPortIsReserved)(port)) {
+        (0, _utils.printAndExit)((0, _getreservedport.getReservedPortExplanation)(port), 1);
+    }
+    if (inspect) {
+        const inspector = await import('inspector');
+        const isInspecting = inspector.url() !== undefined;
+        if (isInspecting) {
+            _log.warn(`The Node.js debugger port is already open at ${process.debugPort}. Ignoring '--inspect${inspect === true ? '' : `="${(0, _utils.formatDebugAddress)(inspect)}"`}'.`);
+        } else {
+            const inspectAddress = inspect === true ? (0, _utils.getParsedDebugAddress)(true) : inspect;
+            // TODO: Implement --inspect-wait
+            const wait = false;
+            try {
+                inspector.open(inspectAddress.port, inspectAddress.host, wait);
+            } catch (error) {
+                console.error(`Failed to start the Node.js inspector with --inspect="${(0, _utils.formatDebugAddress)(inspectAddress)}":`, error);
+                return process.exit(1);
+            }
+        }
+    }
+    if (options.experimentalCpuProf) {
+        _log.info(`CPU profiling enabled. Profile will be saved on exit (Ctrl+C).`);
+        // Save CPU profile on shutdown signals, but let start-server.ts handle graceful exit
+        process.on('SIGTERM', ()=>(0, _cpuprofile.saveCpuProfile)());
+        process.on('SIGINT', ()=>(0, _cpuprofile.saveCpuProfile)());
+    }
+    await (0, _startserver.startServer)({
+        dir,
+        isDev: false,
+        hostname,
+        port,
+        keepAliveTimeout
+    });
+};
+
+//# sourceMappingURL=next-start.js.map

package/dist/standalone/node_modules/next/dist/cli/next-telemetry.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "nextTelemetry", {
+    enumerable: true,
+    get: function() {
+        return nextTelemetry;
+    }
+});
+const _picocolors = require("../lib/picocolors");
+const _storage = require("../telemetry/storage");
+const telemetry = new _storage.Telemetry({
+    distDir: process.cwd()
+});
+let isEnabled = telemetry.isEnabled;
+const nextTelemetry = (options, arg)=>{
+    if (options.enable || arg === 'enable') {
+        telemetry.setEnabled(true);
+        isEnabled = true;
+        console.log((0, _picocolors.cyan)('Success!'));
+    } else if (options.disable || arg === 'disable') {
+        const path = telemetry.setEnabled(false);
+        if (isEnabled) {
+            console.log((0, _picocolors.cyan)(`Your preference has been saved${path ? ` to ${path}` : ''}.`));
+        } else {
+            console.log((0, _picocolors.yellow)(`Next.js' telemetry collection is already disabled.`));
+        }
+        isEnabled = false;
+    } else {
+        console.log((0, _picocolors.bold)('Next.js Telemetry'));
+    }
+    console.log(`\nStatus: ${isEnabled ? (0, _picocolors.bold)((0, _picocolors.green)('Enabled')) : (0, _picocolors.bold)((0, _picocolors.red)('Disabled'))}`);
+    if (isEnabled) {
+        console.log('\nNext.js telemetry is completely anonymous. Thank you for participating!');
+    } else {
+        console.log(`\nYou have opted-out of Next.js' anonymous telemetry program.\nNo data will be collected from your machine.`);
+    }
+    console.log(`\nLearn more: ${(0, _picocolors.cyan)('https://nextjs.org/telemetry')}`);
+};
+
+//# sourceMappingURL=next-telemetry.js.map