vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

package/dist/esm/utils/assertNodeVersion.js

@@ -0,0 +1,11 @@
+export { assertNodeVersion };
+import { assertUsage } from './assert.js';
+import { isNodeJS } from './isNodeJS.js';
+// package.json#engines.node isn't enough as users can ignore it
+function assertNodeVersion() {
+    if (!isNodeJS())
+        return;
+    const version = process.versions.node;
+    const major = parseInt(version.split('.')[0], 10);
+    assertUsage(major >= 16, `Node.js ${version} isn't supported, use Node.js >=16.0.0 instead.`);
+}

package/dist/esm/utils/assertPathIsFilesystemAbsolute.d.ts

@@ -0,0 +1,3 @@
+export { assertPathIsFilesystemAbsolute };
+/** Assert path is absolute from the filesystem root */
+declare function assertPathIsFilesystemAbsolute(p: string): void;

package/dist/esm/utils/assertPathIsFilesystemAbsolute.js

@@ -0,0 +1,14 @@
+export { assertPathIsFilesystemAbsolute };
+import path from 'path';
+import { assert } from './assert.js';
+import { assertPosixPath } from './filesystemPathHandling.js';
+/** Assert path is absolute from the filesystem root */
+function assertPathIsFilesystemAbsolute(p) {
+    assertPosixPath(p);
+    if (process.platform === 'win32') {
+        assert(path.win32.isAbsolute(p));
+    }
+    else {
+        assert(p.startsWith('/'));
+    }
+}

package/dist/esm/utils/assertRoutingType.d.ts

@@ -0,0 +1,6 @@
+export { assertClientRouting };
+export { assertServerRouting };
+export { checkIfClientRouting };
+declare function assertClientRouting(): void;
+declare function checkIfClientRouting(): boolean;
+declare function assertServerRouting(): void;

package/dist/esm/utils/assertRoutingType.js

@@ -0,0 +1,24 @@
+export { assertClientRouting };
+export { assertServerRouting };
+export { checkIfClientRouting };
+import { assertUsage, assertWarning } from './assert.js';
+import { getGlobalObject } from './getGlobalObject.js';
+import { isBrowser } from './isBrowser.js';
+import pc from '@brillout/picocolors';
+const state = getGlobalObject('utils/assertRouterType.ts', {});
+function assertClientRouting() {
+    assertNoContradiction(checkIfClientRouting());
+    state.isClientRouting = true;
+}
+function checkIfClientRouting() {
+    return state.isClientRouting !== false;
+}
+function assertServerRouting() {
+    assertNoContradiction(state.isClientRouting !== true);
+    state.isClientRouting = false;
+}
+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.
+    assertUsage(isBrowser(), `${pc.cyan("import { something } from 'vike/client/router'")} is forbidden on the server-side`, { showStackTrace: true });
+    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/esm/utils/assertSingleInstance.d.ts

@@ -0,0 +1,6 @@
+export { onClientEntry_ServerRouting };
+export { onClientEntry_ClientRouting };
+export { onProjectInfo };
+declare function onClientEntry_ServerRouting(isProduction: boolean): void;
+declare function onClientEntry_ClientRouting(isProduction: boolean): void;
+declare function onProjectInfo(projectVersion: string): void;

package/dist/esm/utils/assertSingleInstance.js

@@ -0,0 +1,94 @@
+export { onClientEntry_ServerRouting };
+export { onClientEntry_ClientRouting };
+export { onProjectInfo };
+//  - 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
+import { unique } from './unique.js';
+import { getGlobalObject } from './getGlobalObject.js';
+/* Use original assertUsage() & assertWarning() after all CJS is removed from node_modules/vike/dist/
+import { assertUsage, assertWarning } from './assert.js'
+*/
+const globalObject = 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 = 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();
+}
+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();
+}
+// 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();
+}
+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/esm/utils/autoRetry.d.ts

@@ -0,0 +1,2 @@
+export { autoRetry };
+declare function autoRetry(fn: () => void | Promise<void>, timeout: number): Promise<void>;

package/dist/esm/utils/autoRetry.js

@@ -0,0 +1,20 @@
+export { autoRetry };
+import { sleep } from './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 sleep(interval);
+    }
+}

package/dist/esm/utils/capitalizeFirstLetter.d.ts

@@ -0,0 +1,2 @@
+export { capitalizeFirstLetter };
+declare function capitalizeFirstLetter(word: string): string;

package/dist/esm/utils/capitalizeFirstLetter.js

@@ -0,0 +1,7 @@
+export { capitalizeFirstLetter };
+function capitalizeFirstLetter(word) {
+    if (!word[0]) {
+        return word;
+    }
+    return word[0].toUpperCase() + word.slice(1);
+}

package/dist/esm/utils/cast.d.ts

@@ -0,0 +1,4 @@
+export { cast };
+export { castProp };
+declare function cast<T>(_thing: unknown): asserts _thing is T;
+declare function castProp<PropType, ObjectType, PropName extends PropertyKey>(_obj: ObjectType, _prop: PropName): asserts _obj is ObjectType & Record<PropName, PropType>;

package/dist/esm/utils/cast.js

@@ -0,0 +1,4 @@
+export { cast };
+export { castProp };
+function cast(_thing) { }
+function castProp(_obj, _prop) { }

package/dist/esm/utils/checkType.d.ts

@@ -0,0 +1,2 @@
+export declare function checkType<Type>(_: Type): void;
+export declare function castType<Cast, Type = {}>(_: Type): asserts _ is Type & Cast;

package/dist/esm/utils/checkType.js

@@ -0,0 +1,2 @@
+export function checkType(_) { }
+export function castType(_) { }

package/dist/esm/utils/compareString.d.ts

@@ -0,0 +1,2 @@
+export { compareString };
+declare function compareString(str1: string, str2: string): number;

package/dist/esm/utils/compareString.js

@@ -0,0 +1,8 @@
+export { compareString };
+function compareString(str1, str2) {
+    if (str1.toLowerCase() < str2.toLowerCase())
+        return -1;
+    if (str1.toLowerCase() > str2.toLowerCase())
+        return 1;
+    return 0;
+}

package/dist/esm/utils/createErrorWithCleanStackTrace.d.ts

@@ -0,0 +1,2 @@
+export { createErrorWithCleanStackTrace };
+declare function createErrorWithCleanStackTrace(errorMessage: string, numberOfStackTraceLinesToRemove: number): Error;

package/dist/esm/utils/createErrorWithCleanStackTrace.js

@@ -0,0 +1,43 @@
+export { createErrorWithCleanStackTrace };
+import { isNodeJS } from './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 (isNodeJS()) {
+        err.stack = clean(err.stack, numberOfStackTraceLinesToRemove);
+    }
+    return err;
+}
+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/);
+}

package/dist/esm/utils/debug.d.ts

@@ -0,0 +1,15 @@
+export { createDebugger };
+export { isDebugEnabled };
+export type { Debug };
+type Namespace = 'vike:error' | 'vike:extractAssets' | 'vike:extractExportNames' | 'vike:glob' | 'vike:pageFiles' | 'vike:log' | 'vike:routing' | 'vike:virtual-files' | 'vike:stem' | 'vike:stream';
+type Debug = ReturnType<typeof createDebugger>;
+type Options = {
+    serialization?: {
+        emptyArray?: string;
+    };
+};
+declare function createDebugger(namespace: Namespace, optionsGlobal?: Options): ((...msgs: unknown[]) => void) & {
+    options: (options: Options) => (...msgs: unknown[]) => void;
+    isEnabled: boolean;
+};
+declare function isDebugEnabled(namespace: Namespace): boolean;

package/dist/esm/utils/debug.js

@@ -0,0 +1,106 @@
+export { createDebugger };
+export { isDebugEnabled };
+import { isBrowser } from './isBrowser.js';
+import { isCallable } from './isCallable.js';
+import { objectAssign } from './objectAssign.js';
+import { assert } from './assert.js';
+import { checkType } from './checkType.js';
+import { getTerminalWidth } from './getTerminWidth.js';
+// Avoid this to be loaded in the browser. For isomorphic code: instead of `import { createDebugger } from './utils.js'`, use `globalThis.createDebugger()`.
+assert(!isBrowser());
+globalThis.__brillout_debug_createDebugger = createDebugger;
+function createDebugger(namespace, optionsGlobal) {
+    checkType(namespace);
+    const debugWithOptions = (options) => {
+        return (...msgs) => {
+            if (!isDebugEnabled(namespace))
+                return;
+            let [msgFirst, ...msgsRest] = msgs;
+            const padding = ' '.repeat(namespace.length + 1);
+            const optionsResolved = { ...optionsGlobal, ...options };
+            msgFirst = formatMsg(msgFirst, optionsResolved, padding, 'FIRST');
+            msgsRest = msgsRest.map((msg, i) => {
+                const position = i === msgsRest.length - 1 ? 'LAST' : 'MIDDLE';
+                return formatMsg(msg, optionsResolved, padding, position);
+            });
+            console.log('\x1b[1m%s\x1b[0m', namespace, msgFirst);
+            msgsRest.forEach((msg) => {
+                console.log(msg);
+            });
+        };
+    };
+    const debug = (...msgs) => debugWithOptions({})(...msgs);
+    objectAssign(debug, { options: debugWithOptions, isEnabled: isDebugEnabled(namespace) });
+    return debug;
+}
+function isDebugEnabled(namespace) {
+    checkType(namespace);
+    let DEBUG;
+    // - `process` can be undefined in edge workers
+    // - We want bundlers to be able to statically replace `process.env.*`
+    try {
+        DEBUG = process.env.DEBUG;
+    }
+    catch { }
+    return DEBUG?.includes(namespace) ?? false;
+}
+function formatMsg(info, options, padding, position) {
+    if (info === undefined) {
+        return undefined;
+    }
+    let str = position === 'FIRST' ? '' : padding;
+    if (typeof info === 'string') {
+        str += info;
+    }
+    else if (Array.isArray(info)) {
+        if (info.length === 0) {
+            str += options.serialization?.emptyArray ?? '[]';
+        }
+        else {
+            str += info.map(strUnknown).join('\n');
+        }
+    }
+    else {
+        str += strUnknown(info);
+    }
+    str = pad(str, padding);
+    if (position !== 'LAST' && position !== 'FIRST') {
+        str += '\n';
+    }
+    return str;
+}
+function pad(str, padding) {
+    const terminalWidth = getTerminalWidth();
+    const lines = [];
+    str.split('\n').forEach((line) => {
+        if (!terminalWidth) {
+            lines.push(line);
+        }
+        else {
+            chunk(line, terminalWidth - padding.length).forEach((chunk) => {
+                lines.push(chunk);
+            });
+        }
+    });
+    return lines.join('\n' + padding);
+}
+function chunk(str, size) {
+    if (str.length <= size) {
+        return [str];
+    }
+    const chunks = str.match(new RegExp('.{1,' + size + '}', 'g'));
+    assert(chunks);
+    return chunks;
+}
+function strUnknown(thing) {
+    return typeof thing === 'string' ? thing : strObj(thing);
+}
+function strObj(obj, newLines = true) {
+    return JSON.stringify(obj, replaceFunctionSerializer, newLines ? 2 : undefined);
+}
+function replaceFunctionSerializer(_key, value) {
+    if (isCallable(value)) {
+        return value.toString().split(/\s+/).join(' ');
+    }
+    return value;
+}

package/dist/esm/utils/debugGlob.d.ts

@@ -0,0 +1,8 @@
+export declare const debugGlob: ((...msgs: unknown[]) => void) & {
+    options: (options: {
+        serialization?: {
+            emptyArray?: string | undefined;
+        } | undefined;
+    }) => (...msgs: unknown[]) => void;
+    isEnabled: boolean;
+};

package/dist/esm/utils/debugGlob.js

@@ -0,0 +1,3 @@
+import { createDebugger } from './debug.js';
+// TODO/v1-release: remove (or rename?)
+export const debugGlob = createDebugger('vike:glob');

package/dist/esm/utils/deepEqual.d.ts

@@ -0,0 +1 @@
+export declare function deepEqual(x: any, y: any): boolean;

package/dist/esm/utils/deepEqual.js

@@ -0,0 +1,7 @@
+// https://stackoverflow.com/questions/201183/how-to-determine-equality-for-two-javascript-objects/32922084#32922084
+export function deepEqual(x, y) {
+    const ok = Object.keys, tx = typeof x, ty = typeof y;
+    return x && y && tx === 'object' && tx === ty
+        ? ok(x).length === ok(y).length && ok(x).every((key) => deepEqual(x[key], y[key]))
+        : x === y;
+}

package/dist/esm/utils/dynamicImport.d.ts

@@ -0,0 +1,2 @@
+/** Only works for npm packages, for files use @brillout/import instead */
+export declare function dynamicImport<Mod = never>(mod: string): Promise<Mod>;

package/dist/esm/utils/dynamicImport.js

@@ -0,0 +1,4 @@
+/** Only works for npm packages, for files use @brillout/import instead */
+export function dynamicImport(mod) {
+    return new Function('mod', 'return import(mod)')(mod);
+}

package/dist/esm/utils/escapeRegex.d.ts

@@ -0,0 +1 @@
+export declare function escapeRegex(str: string): string;

package/dist/esm/utils/escapeRegex.js

@@ -0,0 +1,4 @@
+export function escapeRegex(str) {
+    // https://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript/3561711#3561711
+    return str.replace(/[/\-\\^$*+?.()|[\]{}]/g, '\\$&');
+}

package/dist/esm/utils/filesystemPathHandling.d.ts

@@ -0,0 +1,4 @@
+export { toPosixPath };
+export { assertPosixPath };
+declare function toPosixPath(path: string): string;
+declare function assertPosixPath(path: string): void;

package/dist/esm/utils/filesystemPathHandling.js

@@ -0,0 +1,16 @@
+export { toPosixPath };
+export { assertPosixPath };
+import { assert } from './assert.js';
+function toPosixPath(path) {
+    const pathPosix = path.split('\\').join('/');
+    assertPosixPath(pathPosix);
+    return pathPosix;
+}
+function assertPosixPath(path) {
+    const errMsg = (msg) => `Not a posix path: ${msg}`;
+    assert(path !== null, errMsg('null'));
+    assert(typeof path === 'string', errMsg(`typeof path === ${JSON.stringify(typeof path)}`));
+    assert(path !== '', errMsg('(empty string)'));
+    assert(path);
+    assert(!path.includes('\\'), errMsg(path));
+}

package/dist/esm/utils/findUserPackageJsonPath.d.ts

@@ -0,0 +1,2 @@
+export { findUserPackageJsonPath };
+declare function findUserPackageJsonPath(userDir: string): null | string;

package/dist/esm/utils/findUserPackageJsonPath.js

@@ -0,0 +1,18 @@
+export { findUserPackageJsonPath };
+import path from 'path';
+import fs from 'fs';
+function findUserPackageJsonPath(userDir) {
+    let dir = userDir;
+    while (true) {
+        const configFilePath = path.join(dir, './package.json');
+        if (fs.existsSync(configFilePath)) {
+            // return toPosixPath(configFilePath)
+            return configFilePath;
+        }
+        const dirPrevious = dir;
+        dir = path.dirname(dir);
+        if (dir === dirPrevious) {
+            return null;
+        }
+    }
+}

package/dist/esm/utils/freezePartial.d.ts

@@ -0,0 +1,2 @@
+export { freezePartial };
+declare function freezePartial(obj: Record<string, unknown>, allowList: Record<string, (val: unknown) => boolean>): void;

package/dist/esm/utils/freezePartial.js

@@ -0,0 +1,30 @@
+export { freezePartial };
+import pc from '@brillout/picocolors';
+// Unit tests at ./freezePartial.spec.ts
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+assertIsNotBrowser();
+function freezePartial(obj, allowList) {
+    Object.entries(obj).forEach(([key, val]) => {
+        Object.defineProperty(obj, key, {
+            get() {
+                return val;
+            },
+            set(newVal) {
+                if (key in allowList) {
+                    const isAllowed = allowList[key](newVal);
+                    if (isAllowed) {
+                        val = newVal;
+                        return;
+                    }
+                    else {
+                        throw new Error(`Setting wrong value ${pc.cyan(JSON.stringify(newVal))} for property ${pc.cyan(key)}`);
+                    }
+                }
+                throw new Error(`You aren't allowed to mutate property ${pc.cyan(key)}`);
+            },
+            configurable: false,
+            enumerable: true
+        });
+    });
+    Object.preventExtensions(obj);
+}

package/dist/esm/utils/getCurrentUrl.d.ts

@@ -0,0 +1,4 @@
+export { getCurrentUrl };
+declare function getCurrentUrl(options?: {
+    withoutHash: true;
+}): string;

package/dist/esm/utils/getCurrentUrl.js

@@ -0,0 +1,16 @@
+export { getCurrentUrl };
+import { parseUrl } from './parseUrl.js';
+import { assert } from './assert.js';
+function getCurrentUrl(options) {
+    const url = window.location.href;
+    const { searchOriginal, hashOriginal, pathname } = parseUrl(url, '/');
+    let urlCurrent;
+    if (options?.withoutHash) {
+        urlCurrent = `${pathname}${searchOriginal || ''}`;
+    }
+    else {
+        urlCurrent = `${pathname}${searchOriginal || ''}${hashOriginal || ''}`;
+    }
+    assert(urlCurrent.startsWith('/'));
+    return urlCurrent;
+}

package/dist/esm/utils/getDependencyPackageJson.d.ts

@@ -0,0 +1,6 @@
+export { getDependencyPackageJson };
+export { getDependencyPackageJsonPath };
+export { getDependencyRootDir };
+declare function getDependencyPackageJson(npmPackageName: string, userAppRootDir: string): Record<string, unknown>;
+declare function getDependencyRootDir(npmPackageName: string, userAppRootDir: string): string;
+declare function getDependencyPackageJsonPath(npmPackageName: string, userAppRootDir: string): string;