vike 0.0.0-alpha.0 → 0.4.142-commit-6eb0dd3

package/dist/cjs/utils/arrayIncludes.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayIncludes = void 0;
+function arrayIncludes(arr, el) {
+    return arr.includes(el);
+}
+exports.arrayIncludes = arrayIncludes;

package/dist/cjs/utils/assert.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBug = exports.overwriteAssertProductionLogger = exports.getAssertErrMsg = exports.addOnBeforeLogHook = exports.getProjectError = exports.assertInfo = exports.assertWarning = exports.assertUsage = exports.assert = void 0;
+const createErrorWithCleanStackTrace_js_1 = require("./createErrorWithCleanStackTrace.js");
+const getGlobalObject_js_1 = require("./getGlobalObject.js");
+const isObject_js_1 = require("./isObject.js");
+const projectInfo_js_1 = require("./projectInfo.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/assert.ts', {
+    alreadyLogged: new Set(),
+    // Production logger. Overwritten by loggerNotProd.ts in non-production environments.
+    logger(msg, logType) {
+        if (logType === 'info') {
+            console.log(msg);
+        }
+        else {
+            console.warn(msg);
+        }
+    },
+    showStackTraceList: new WeakSet()
+});
+const projectTag = `[${projectInfo_js_1.projectInfo.npmPackageName}]`;
+const projectTagWithVersion = `[${projectInfo_js_1.projectInfo.npmPackageName}@${projectInfo_js_1.projectInfo.projectVersion}]`;
+const numberOfStackTraceLinesToRemove = 2;
+function assert(condition, debugInfo) {
+    if (condition)
+        return;
+    const debugStr = (() => {
+        if (!debugInfo) {
+            return null;
+        }
+        const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : JSON.stringify(debugInfo);
+        return picocolors_1.default.dim(`Debug info (for ${projectInfo_js_1.projectInfo.projectName} maintainers; you can ignore this): ${debugInfoSerialized}`);
+    })();
+    const link = `${projectInfo_js_1.projectInfo.githubRepository}/issues/new`;
+    let errMsg = [
+        `You stumbled upon a bug in ${projectInfo_js_1.projectInfo.projectName}'s source code.`,
+        `Go to ${picocolors_1.default.blue(link)} and copy-paste this error; a maintainer will fix the bug (usually under 24 hours).`,
+        debugStr
+    ]
+        .filter(Boolean)
+        .join(' ');
+    errMsg = addWhitespace(errMsg);
+    errMsg = addPrefixAssertType(errMsg, 'Bug');
+    errMsg = addPrefixProjctName(errMsg, true);
+    const internalError = (0, createErrorWithCleanStackTrace_js_1.createErrorWithCleanStackTrace)(errMsg, numberOfStackTraceLinesToRemove);
+    globalObject.onBeforeLog?.();
+    throw internalError;
+}
+exports.assert = assert;
+function assertUsage(condition, errMsg, { showStackTrace } = {}) {
+    if (condition)
+        return;
+    errMsg = addWhitespace(errMsg);
+    errMsg = addPrefixAssertType(errMsg, 'Wrong Usage');
+    errMsg = addPrefixProjctName(errMsg);
+    const usageError = (0, createErrorWithCleanStackTrace_js_1.createErrorWithCleanStackTrace)(errMsg, numberOfStackTraceLinesToRemove);
+    if (showStackTrace) {
+        globalObject.showStackTraceList.add(usageError);
+    }
+    globalObject.onBeforeLog?.();
+    throw usageError;
+}
+exports.assertUsage = assertUsage;
+function getProjectError(errMsg) {
+    errMsg = addWhitespace(errMsg);
+    errMsg = addPrefixAssertType(errMsg, 'Error');
+    errMsg = addPrefixProjctName(errMsg);
+    const projectError = (0, createErrorWithCleanStackTrace_js_1.createErrorWithCleanStackTrace)(errMsg, numberOfStackTraceLinesToRemove);
+    return projectError;
+}
+exports.getProjectError = getProjectError;
+function assertWarning(condition, msg, { onlyOnce, showStackTrace }) {
+    if (condition)
+        return;
+    msg = addWhitespace(msg);
+    msg = addPrefixAssertType(msg, 'Warning');
+    msg = addPrefixProjctName(msg);
+    if (onlyOnce) {
+        const { alreadyLogged } = globalObject;
+        const key = onlyOnce === true ? msg : onlyOnce;
+        if (alreadyLogged.has(key)) {
+            return;
+        }
+        else {
+            alreadyLogged.add(key);
+        }
+    }
+    globalObject.onBeforeLog?.();
+    if (showStackTrace) {
+        const err = new Error(msg);
+        globalObject.showStackTraceList.add(err);
+        globalObject.logger(err, 'warn');
+    }
+    else {
+        globalObject.logger(msg, 'warn');
+    }
+}
+exports.assertWarning = assertWarning;
+function assertInfo(condition, msg, { onlyOnce }) {
+    if (condition) {
+        return;
+    }
+    msg = addWhitespace(msg);
+    msg = addPrefixProjctName(msg);
+    if (onlyOnce) {
+        const { alreadyLogged } = globalObject;
+        const key = msg;
+        if (alreadyLogged.has(key)) {
+            return;
+        }
+        else {
+            alreadyLogged.add(key);
+        }
+    }
+    globalObject.onBeforeLog?.();
+    globalObject.logger(msg, 'info');
+}
+exports.assertInfo = assertInfo;
+function addOnBeforeLogHook(onBeforeLog) {
+    globalObject.onBeforeLog = onBeforeLog;
+}
+exports.addOnBeforeLogHook = addOnBeforeLogHook;
+function addPrefixAssertType(msg, tag) {
+    let prefix = `[${tag}]`;
+    const color = tag === 'Warning' ? 'yellow' : 'red';
+    prefix = picocolors_1.default.bold(picocolors_1.default[color](prefix));
+    return `${prefix}${msg}`;
+}
+function addWhitespace(msg) {
+    if (msg.startsWith('[')) {
+        return msg;
+    }
+    else {
+        return ` ${msg}`;
+    }
+}
+function addPrefixProjctName(msg, showProjectVersion = false) {
+    const prefix = showProjectVersion ? projectTagWithVersion : projectTag;
+    return `${prefix}${msg}`;
+}
+function getAssertErrMsg(thing) {
+    let errMsg;
+    let errStack = null;
+    if (typeof thing === 'string') {
+        errMsg = thing;
+    }
+    else if ((0, isObject_js_1.isObject)(thing) && typeof thing.message === 'string' && typeof thing.stack === 'string') {
+        errMsg = thing.message;
+        errStack = thing.stack;
+    }
+    else {
+        return null;
+    }
+    let assertMsg;
+    let isBug;
+    if (errMsg.startsWith(projectTag)) {
+        assertMsg = errMsg.slice(projectTag.length);
+        isBug = false;
+    }
+    else if (errMsg.startsWith(projectTagWithVersion)) {
+        assertMsg = errMsg.slice(projectTagWithVersion.length);
+        isBug = true;
+    }
+    else {
+        return null;
+    }
+    // Append stack trace
+    if (errStack && (isBug || globalObject.showStackTraceList.has(thing))) {
+        assertMsg = `${assertMsg}\n${removeErrMsg(errStack)}`;
+    }
+    const showVikeVersion = isBug;
+    return { assertMsg, showVikeVersion };
+}
+exports.getAssertErrMsg = getAssertErrMsg;
+function removeErrMsg(stack) {
+    if (typeof stack !== 'string')
+        return String(stack);
+    const [firstLine, ...stackLines] = stack.split('\n');
+    if (!firstLine.startsWith('Error: '))
+        return stack;
+    return stackLines.join('\n');
+}
+function overwriteAssertProductionLogger(logger) {
+    globalObject.logger = logger;
+}
+exports.overwriteAssertProductionLogger = overwriteAssertProductionLogger;
+function isBug(err) {
+    return !String(err).includes('[Bug]');
+}
+exports.isBug = isBug;

package/dist/cjs/utils/assertDefaultExport.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertDefaultExportObject = exports.assertDefaultExportUnknown = void 0;
+const assert_js_1 = require("./assert.js");
+const isObject_js_1 = require("./isObject.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const IGNORE = [
+    // vite-plugin-solid adds `export { $$registrations }`
+    '$$registrations',
+    // @vitejs/plugin-vue adds `export { _rerender_only }`
+    '_rerender_only'
+];
+// support `export { frontmatter }` in .mdx files
+const FILES_WITH_SIDE_EXPORTS = ['.md', '.mdx'];
+function assertDefaultExportUnknown(fileExports, filePath) {
+    assertSingleDefaultExport(fileExports, filePath, true);
+}
+exports.assertDefaultExportUnknown = assertDefaultExportUnknown;
+function assertDefaultExportObject(fileExports, filePath) {
+    assertSingleDefaultExport(fileExports, filePath, false);
+    const exportDefault = fileExports.default;
+    (0, assert_js_1.assertUsage)((0, isObject_js_1.isObject)(exportDefault), `The ${picocolors_1.default.cyan('export default')} of ${filePath} should be an object (but it's ${picocolors_1.default.cyan(`typeof exportDefault === ${JSON.stringify(typeof exportDefault)}`)} instead)`);
+}
+exports.assertDefaultExportObject = assertDefaultExportObject;
+function assertSingleDefaultExport(fileExports, filePath, defaultExportValueIsUnknown) {
+    const exportsAll = Object.keys(fileExports);
+    const exportsRelevant = exportsAll.filter((exportName) => !IGNORE.includes(exportName));
+    const exportsInvalid = exportsRelevant.filter((e) => e !== 'default');
+    const exportsHasDefault = exportsRelevant.includes('default');
+    if (exportsInvalid.length === 0) {
+        if (exportsHasDefault) {
+            return;
+        }
+        else {
+            (0, assert_js_1.assert)(exportsRelevant.length === 0);
+            (0, assert_js_1.assertUsage)(false, `${filePath} doesn't export any value, but it should have a ${picocolors_1.default.cyan('export default')} instead`);
+        }
+    }
+    else if (!FILES_WITH_SIDE_EXPORTS.some((ext) => filePath.endsWith(ext))) {
+        if (defaultExportValueIsUnknown) {
+            exportsInvalid.forEach((exportInvalid) => {
+                (0, assert_js_1.assertWarning)(exportsInvalid.length === 0, `${filePath} should only have a default export: move ${picocolors_1.default.cyan(`export { ${exportInvalid} }`)} to +config.h.js or its own +${exportsInvalid}.js`, { onlyOnce: true });
+            });
+        }
+        else {
+            const exportsInvalidStr = exportsInvalid.join(', ');
+            (0, assert_js_1.assertWarning)(exportsInvalid.length === 0, `${filePath} replace ${picocolors_1.default.cyan(`export { ${exportsInvalidStr} }`)} with ${picocolors_1.default.cyan(`export default { ${exportsInvalidStr} }`)}`, { onlyOnce: true });
+        }
+    }
+}

package/dist/cjs/utils/assertIsBrowser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsBrowser = void 0;
+const isBrowser_js_1 = require("./isBrowser.js");
+const assert_js_1 = require("./assert.js");
+function assertIsBrowser() {
+    (0, assert_js_1.assert)((0, isBrowser_js_1.isBrowser)());
+}
+exports.assertIsBrowser = assertIsBrowser;

package/dist/cjs/utils/assertIsNotBrowser.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsNotBrowser = void 0;
+const isBrowser_js_1 = require("./isBrowser.js");
+const assert_js_1 = require("./assert.js");
+/** Ensure we don't bloat the client-side */
+function assertIsNotBrowser() {
+    (0, assert_js_1.assert)(!(0, isBrowser_js_1.isBrowser)());
+}
+exports.assertIsNotBrowser = assertIsNotBrowser;

package/dist/cjs/utils/assertIsNotProductionRuntime.js

@@ -0,0 +1,44 @@
+"use strict";
+// Mechanism to ensure code isn't loaded by production runtime
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertEnv = exports.markEnvAsVite = exports.markEnvAsPreview = exports.markEnvAsDev = exports.assertIsNotProductionRuntime = void 0;
+const assert_js_1 = require("./assert.js");
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+const getGlobalObject_js_1 = require("./getGlobalObject.js");
+const isVitest_js_1 = require("./isVitest.js");
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+const env = (0, getGlobalObject_js_1.getGlobalObject)('utils/assertIsNotProductionRuntime.ts', {});
+// Called by *.ts that want to ensure that they aren't loaded by the server runtime in production
+function assertIsNotProductionRuntime() {
+    env.shouldBeVite = true;
+}
+exports.assertIsNotProductionRuntime = assertIsNotProductionRuntime;
+// Called by Vite hook configureServer()
+function markEnvAsDev() {
+    env.isDev = true;
+}
+exports.markEnvAsDev = markEnvAsDev;
+// Called by Vite hook configurePreviewServer()
+function markEnvAsPreview() {
+    env.isPreview = true;
+}
+exports.markEnvAsPreview = markEnvAsPreview;
+// Called by ../node/plugin/index.ts
+function markEnvAsVite() {
+    env.isVite = true;
+}
+exports.markEnvAsVite = markEnvAsVite;
+// Called by ../node/runtime/index.ts
+function assertEnv() {
+    if ((0, isVitest_js_1.isVitest)())
+        return;
+    if (env.isDev || env.isPreview) {
+        (0, assert_js_1.assert)(env.isVite);
+        (0, assert_js_1.assert)(env.shouldBeVite);
+    }
+    else {
+        (0, assert_js_1.assert)(!env.isVite);
+        (0, assert_js_1.assert)(!env.shouldBeVite);
+    }
+}
+exports.assertEnv = assertEnv;

package/dist/cjs/utils/assertNodeVersion.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNodeVersion = void 0;
+const assert_js_1 = require("./assert.js");
+const isNodeJS_js_1 = require("./isNodeJS.js");
+// package.json#engines.node isn't enough as users can ignore it
+function assertNodeVersion() {
+    if (!(0, isNodeJS_js_1.isNodeJS)())
+        return;
+    const version = process.versions.node;
+    const major = parseInt(version.split('.')[0], 10);
+    (0, assert_js_1.assertUsage)(major >= 16, `Node.js ${version} isn't supported, use Node.js >=16.0.0 instead.`);
+}
+exports.assertNodeVersion = assertNodeVersion;

package/dist/cjs/utils/assertPathIsFilesystemAbsolute.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPathIsFilesystemAbsolute = void 0;
+const path_1 = __importDefault(require("path"));
+const assert_js_1 = require("./assert.js");
+const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
+/** Assert path is absolute from the filesystem root */
+function assertPathIsFilesystemAbsolute(p) {
+    (0, filesystemPathHandling_js_1.assertPosixPath)(p);
+    if (process.platform === 'win32') {
+        (0, assert_js_1.assert)(path_1.default.win32.isAbsolute(p));
+    }
+    else {
+        (0, assert_js_1.assert)(p.startsWith('/'));
+    }
+}
+exports.assertPathIsFilesystemAbsolute = assertPathIsFilesystemAbsolute;

package/dist/cjs/utils/assertRoutingType.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIfClientRouting = exports.assertServerRouting = exports.assertClientRouting = void 0;
+const assert_js_1 = require("./assert.js");
+const getGlobalObject_js_1 = require("./getGlobalObject.js");
+const isBrowser_js_1 = require("./isBrowser.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const state = (0, getGlobalObject_js_1.getGlobalObject)('utils/assertRouterType.ts', {});
+function assertClientRouting() {
+    assertNoContradiction(checkIfClientRouting());
+    state.isClientRouting = true;
+}
+exports.assertClientRouting = assertClientRouting;
+function checkIfClientRouting() {
+    return state.isClientRouting !== false;
+}
+exports.checkIfClientRouting = checkIfClientRouting;
+function assertServerRouting() {
+    assertNoContradiction(state.isClientRouting !== true);
+    state.isClientRouting = false;
+}
+exports.assertServerRouting = assertServerRouting;
+function assertNoContradiction(noContradiction) {
+    // If an assertion fails because of a wrong usage, then we assume that the user is trying to import from 'vike/client/router' while not setting `clientRouting` to `true`. Note that 'vike/client' only exports the type `PageContextBuiltInClient` and that the package.json#exports entry 'vike/client' will eventually be removed.
+    (0, assert_js_1.assertUsage)((0, isBrowser_js_1.isBrowser)(), `${picocolors_1.default.cyan("import { something } from 'vike/client/router'")} is forbidden on the server-side`, { showStackTrace: true });
+    (0, assert_js_1.assertWarning)(noContradiction, "You shouldn't `import { something } from 'vike/client/router'` when using Server Routing. The 'vike/client/router' utilities work only with Client Routing. In particular, don't `import { navigate }` nor `import { prefetch }` as they unnecessarily bloat your client-side bundle sizes.", { showStackTrace: true, onlyOnce: true });
+}

package/dist/cjs/utils/assertSingleInstance.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onProjectInfo = exports.onClientEntry_ClientRouting = exports.onClientEntry_ServerRouting = void 0;
+//  - Throw error if there are two different versions of vike loaded
+//  - Show warning if entry of Client Routing and entry of Server Routing are both loaded
+//  - Show warning if vike is loaded twice
+const unique_js_1 = require("./unique.js");
+const getGlobalObject_js_1 = require("./getGlobalObject.js");
+/* Use original assertUsage() & assertWarning() after all CJS is removed from node_modules/vike/dist/
+import { assertUsage, assertWarning } from './assert.js'
+*/
+const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('assertPackageInstances.ts', {
+    instances: [],
+    alreadyLogged: new Set()
+});
+const clientRuntimesClonflict = "The client runtime of Server Routing as well as the client runtime of Client Routing are both being loaded. Make sure they aren't loaded both at the same time for a given page. See https://vike.dev/client-runtimes-conflict";
+const clientNotSingleInstance = "Two vike client runtime instances are being loaded. Make sure your client-side bundles don't include vike twice. (In order to reduce the size of your client-side JavaScript bundles.)";
+function assertSingleInstance() {
+    {
+        const versions = (0, unique_js_1.unique)(globalObject.instances);
+        assertUsage(versions.length <= 1, 
+        // DO *NOT* patch vike to remove this error: because of multiple conflicting versions, you *will* eventually encounter insidious issues that hard to debug and potentially a security hazard, see for example https://github.com/vikejs/vike/issues/1108
+        `Both vike@${versions[0]} and vike@${versions[1]} loaded. Only one version should be loaded.`);
+    }
+    if (globalObject.checkSingleInstance && globalObject.instances.length > 1) {
+        /*/ Not sure whether circular dependency can cause problems? In principle not since client-side code is ESM.
+        console.warn(clientNotSingleInstance)
+        /*/
+        assertWarning(false, clientNotSingleInstance, { onlyOnce: true, showStackTrace: true });
+        //*/
+    }
+}
+function onClientEntry_ServerRouting(isProduction) {
+    assertWarning(globalObject.isClientRouting !== true, clientRuntimesClonflict, {
+        onlyOnce: true,
+        showStackTrace: true
+    });
+    assertWarning(globalObject.isClientRouting === undefined, clientNotSingleInstance, {
+        onlyOnce: true,
+        showStackTrace: true
+    });
+    globalObject.isClientRouting = false;
+    if (isProduction)
+        globalObject.checkSingleInstance = true;
+    assertSingleInstance();
+}
+exports.onClientEntry_ServerRouting = onClientEntry_ServerRouting;
+function onClientEntry_ClientRouting(isProduction) {
+    assertWarning(globalObject.isClientRouting !== false, clientRuntimesClonflict, {
+        onlyOnce: true,
+        showStackTrace: true
+    });
+    assertWarning(globalObject.isClientRouting === undefined, clientNotSingleInstance, {
+        onlyOnce: true,
+        showStackTrace: true
+    });
+    globalObject.isClientRouting = true;
+    if (isProduction)
+        globalObject.checkSingleInstance = true;
+    assertSingleInstance();
+}
+exports.onClientEntry_ClientRouting = onClientEntry_ClientRouting;
+// Called by utils/projectInfo.ts which is loaded by all entries (since utils/asserts.ts depends on utils/projectInfo.ts, we can have confidence that onProjectInfo() is called by each entry). That way we don't have to call a callback for every entry (there are a *lot* of entries: `client/router/`, `client/`, `node/runtime/`, `node/plugin/`, `node/cli`).
+function onProjectInfo(projectVersion) {
+    globalObject.instances.push(projectVersion);
+    assertSingleInstance();
+}
+exports.onProjectInfo = onProjectInfo;
+function assertUsage(condition, errorMessage) {
+    if (condition) {
+        return;
+    }
+    const errMsg = `[vike][Wrong Usage] ${errorMessage}`;
+    throw new Error(errMsg);
+}
+function assertWarning(condition, errorMessage, { onlyOnce, showStackTrace }) {
+    if (condition) {
+        return;
+    }
+    const msg = `[vike][Warning] ${errorMessage}`;
+    if (onlyOnce) {
+        const { alreadyLogged } = globalObject;
+        const key = onlyOnce === true ? msg : onlyOnce;
+        if (alreadyLogged.has(key)) {
+            return;
+        }
+        else {
+            alreadyLogged.add(key);
+        }
+    }
+    if (showStackTrace) {
+        console.warn(new Error(msg));
+    }
+    else {
+        console.warn(msg);
+    }
+}

package/dist/cjs/utils/autoRetry.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoRetry = void 0;
+const sleep_js_1 = require("./sleep.js");
+async function autoRetry(fn, timeout) {
+    const interval = 30;
+    const numberOfTries = timeout / interval;
+    let i = 0;
+    while (true) {
+        try {
+            await fn();
+            return;
+        }
+        catch (err) {
+            i = i + 1;
+            if (i > numberOfTries) {
+                throw err;
+            }
+        }
+        await (0, sleep_js_1.sleep)(interval);
+    }
+}
+exports.autoRetry = autoRetry;

package/dist/cjs/utils/capitalizeFirstLetter.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalizeFirstLetter = void 0;
+function capitalizeFirstLetter(word) {
+    if (!word[0]) {
+        return word;
+    }
+    return word[0].toUpperCase() + word.slice(1);
+}
+exports.capitalizeFirstLetter = capitalizeFirstLetter;

package/dist/cjs/utils/cast.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.castProp = exports.cast = void 0;
+function cast(_thing) { }
+exports.cast = cast;
+function castProp(_obj, _prop) { }
+exports.castProp = castProp;

package/dist/cjs/utils/checkType.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.castType = exports.checkType = void 0;
+function checkType(_) { }
+exports.checkType = checkType;
+function castType(_) { }
+exports.castType = castType;

package/dist/cjs/utils/compareString.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareString = void 0;
+function compareString(str1, str2) {
+    if (str1.toLowerCase() < str2.toLowerCase())
+        return -1;
+    if (str1.toLowerCase() > str2.toLowerCase())
+        return 1;
+    return 0;
+}
+exports.compareString = compareString;

package/dist/cjs/utils/createErrorWithCleanStackTrace.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createErrorWithCleanStackTrace = void 0;
+const isNodeJS_js_1 = require("./isNodeJS.js");
+function createErrorWithCleanStackTrace(errorMessage, numberOfStackTraceLinesToRemove) {
+    let err;
+    {
+        var stackTraceLimit__original = Error.stackTraceLimit;
+        Error.stackTraceLimit = Infinity;
+        err = new Error(errorMessage);
+        Error.stackTraceLimit = stackTraceLimit__original;
+    }
+    if ((0, isNodeJS_js_1.isNodeJS)()) {
+        err.stack = clean(err.stack, numberOfStackTraceLinesToRemove);
+    }
+    return err;
+}
+exports.createErrorWithCleanStackTrace = createErrorWithCleanStackTrace;
+function clean(errStack, numberOfStackTraceLinesToRemove) {
+    if (!errStack) {
+        return errStack;
+    }
+    const stackLines = splitByLine(errStack);
+    let linesRemoved = 0;
+    const stackLine__cleaned = stackLines
+        .filter((line) => {
+        // Remove internal stack traces
+        if (line.includes(' (internal/') || line.includes(' (node:internal')) {
+            return false;
+        }
+        if (linesRemoved < numberOfStackTraceLinesToRemove && isStackTraceLine(line)) {
+            linesRemoved++;
+            return false;
+        }
+        return true;
+    })
+        .join('\n');
+    return stackLine__cleaned;
+}
+function isStackTraceLine(line) {
+    return line.startsWith('    at ');
+}
+function splitByLine(str) {
+    // https://stackoverflow.com/questions/21895233/how-in-node-to-split-string-by-newline-n
+    return str.split(/\r?\n/);
+}