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

package/dist/cjs/utils/debug.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDebugEnabled = exports.createDebugger = void 0;
+const isBrowser_js_1 = require("./isBrowser.js");
+const isCallable_js_1 = require("./isCallable.js");
+const objectAssign_js_1 = require("./objectAssign.js");
+const assert_js_1 = require("./assert.js");
+const checkType_js_1 = require("./checkType.js");
+const getTerminWidth_js_1 = require("./getTerminWidth.js");
+// Avoid this to be loaded in the browser. For isomorphic code: instead of `import { createDebugger } from './utils.js'`, use `globalThis.createDebugger()`.
+(0, assert_js_1.assert)(!(0, isBrowser_js_1.isBrowser)());
+globalThis.__brillout_debug_createDebugger = createDebugger;
+function createDebugger(namespace, optionsGlobal) {
+    (0, checkType_js_1.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);
+    (0, objectAssign_js_1.objectAssign)(debug, { options: debugWithOptions, isEnabled: isDebugEnabled(namespace) });
+    return debug;
+}
+exports.createDebugger = createDebugger;
+function isDebugEnabled(namespace) {
+    (0, checkType_js_1.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;
+}
+exports.isDebugEnabled = isDebugEnabled;
+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 = (0, getTerminWidth_js_1.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'));
+    (0, assert_js_1.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 ((0, isCallable_js_1.isCallable)(value)) {
+        return value.toString().split(/\s+/).join(' ');
+    }
+    return value;
+}

package/dist/cjs/utils/debugGlob.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugGlob = void 0;
+const debug_js_1 = require("./debug.js");
+// TODO/v1-release: remove (or rename?)
+exports.debugGlob = (0, debug_js_1.createDebugger)('vike:glob');

package/dist/cjs/utils/deepEqual.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepEqual = void 0;
+// https://stackoverflow.com/questions/201183/how-to-determine-equality-for-two-javascript-objects/32922084#32922084
+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;
+}
+exports.deepEqual = deepEqual;

package/dist/cjs/utils/dynamicImport.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamicImport = void 0;
+/** Only works for npm packages, for files use @brillout/import instead */
+function dynamicImport(mod) {
+    return new Function('mod', 'return import(mod)')(mod);
+}
+exports.dynamicImport = dynamicImport;

package/dist/cjs/utils/escapeRegex.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeRegex = void 0;
+function escapeRegex(str) {
+    // https://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript/3561711#3561711
+    return str.replace(/[/\-\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+exports.escapeRegex = escapeRegex;

package/dist/cjs/utils/filesystemPathHandling.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPosixPath = exports.toPosixPath = void 0;
+const assert_js_1 = require("./assert.js");
+function toPosixPath(path) {
+    const pathPosix = path.split('\\').join('/');
+    assertPosixPath(pathPosix);
+    return pathPosix;
+}
+exports.toPosixPath = toPosixPath;
+function assertPosixPath(path) {
+    const errMsg = (msg) => `Not a posix path: ${msg}`;
+    (0, assert_js_1.assert)(path !== null, errMsg('null'));
+    (0, assert_js_1.assert)(typeof path === 'string', errMsg(`typeof path === ${JSON.stringify(typeof path)}`));
+    (0, assert_js_1.assert)(path !== '', errMsg('(empty string)'));
+    (0, assert_js_1.assert)(path);
+    (0, assert_js_1.assert)(!path.includes('\\'), errMsg(path));
+}
+exports.assertPosixPath = assertPosixPath;

package/dist/cjs/utils/findUserPackageJsonPath.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findUserPackageJsonPath = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+function findUserPackageJsonPath(userDir) {
+    let dir = userDir;
+    while (true) {
+        const configFilePath = path_1.default.join(dir, './package.json');
+        if (fs_1.default.existsSync(configFilePath)) {
+            // return toPosixPath(configFilePath)
+            return configFilePath;
+        }
+        const dirPrevious = dir;
+        dir = path_1.default.dirname(dir);
+        if (dir === dirPrevious) {
+            return null;
+        }
+    }
+}
+exports.findUserPackageJsonPath = findUserPackageJsonPath;

package/dist/cjs/utils/freezePartial.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.freezePartial = void 0;
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+// Unit tests at ./freezePartial.spec.ts
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+(0, assertIsNotBrowser_js_1.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 ${picocolors_1.default.cyan(JSON.stringify(newVal))} for property ${picocolors_1.default.cyan(key)}`);
+                    }
+                }
+                throw new Error(`You aren't allowed to mutate property ${picocolors_1.default.cyan(key)}`);
+            },
+            configurable: false,
+            enumerable: true
+        });
+    });
+    Object.preventExtensions(obj);
+}
+exports.freezePartial = freezePartial;

package/dist/cjs/utils/getCurrentUrl.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentUrl = void 0;
+const parseUrl_js_1 = require("./parseUrl.js");
+const assert_js_1 = require("./assert.js");
+function getCurrentUrl(options) {
+    const url = window.location.href;
+    const { searchOriginal, hashOriginal, pathname } = (0, parseUrl_js_1.parseUrl)(url, '/');
+    let urlCurrent;
+    if (options?.withoutHash) {
+        urlCurrent = `${pathname}${searchOriginal || ''}`;
+    }
+    else {
+        urlCurrent = `${pathname}${searchOriginal || ''}${hashOriginal || ''}`;
+    }
+    (0, assert_js_1.assert)(urlCurrent.startsWith('/'));
+    return urlCurrent;
+}
+exports.getCurrentUrl = getCurrentUrl;

package/dist/cjs/utils/getDependencyPackageJson.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDependencyRootDir = exports.getDependencyPackageJsonPath = exports.getDependencyPackageJson = void 0;
+// There doesn't seem to be any alternative:
+//  - https://github.com/antfu/local-pkg
+//  - https://stackoverflow.com/questions/74640378/find-and-read-package-json-of-a-dependency
+//  - https://stackoverflow.com/questions/58442451/finding-the-root-directory-of-a-dependency-in-npm
+//  - https://stackoverflow.com/questions/10111163/how-can-i-get-the-path-of-a-module-i-have-loaded-via-require-that-is-not-mine/63441056#63441056
+const assert_js_1 = require("./assert.js");
+const isNpmPackage_js_1 = require("./isNpmPackage.js");
+const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
+const isObject_js_1 = require("./isObject.js");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const assertIsNotProductionRuntime_js_1 = require("./assertIsNotProductionRuntime.js");
+const module_1 = require("module");
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = `file://${__filename}`;
+const require_ = (0, module_1.createRequire)(importMetaUrl);
+(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+function getDependencyPackageJson(npmPackageName, userAppRootDir) {
+    const packageJsonPath = getDependencyPackageJsonPath(npmPackageName, userAppRootDir);
+    const packageJson = fs_1.default.readFileSync(packageJsonPath, 'utf8');
+    (0, assert_js_1.assert)((0, isObject_js_1.isObject)(packageJson));
+    return packageJson;
+}
+exports.getDependencyPackageJson = getDependencyPackageJson;
+function getDependencyRootDir(npmPackageName, userAppRootDir) {
+    const rootDir = path_1.default.posix.dirname(getDependencyPackageJsonPath(npmPackageName, userAppRootDir));
+    return rootDir;
+}
+exports.getDependencyRootDir = getDependencyRootDir;
+function getDependencyPackageJsonPath(npmPackageName, userAppRootDir) {
+    (0, assert_js_1.assert)((0, isNpmPackage_js_1.isNpmPackageName)(npmPackageName));
+    let packageJsonPath = resolvePackageJsonDirectly(npmPackageName, userAppRootDir);
+    if (!packageJsonPath) {
+        packageJsonPath = resolvePackageJsonWithMainEntry(npmPackageName, userAppRootDir);
+    }
+    (0, assert_js_1.assertUsage)(packageJsonPath, `Cannot read ${npmPackageName}/package.json. Define package.json#exports["./package.json"] with the value "./package.json" in the package.json of ${npmPackageName}.`);
+    packageJsonPath = (0, filesystemPathHandling_js_1.toPosixPath)(packageJsonPath);
+    (0, assert_js_1.assert)(packageJsonPath.endsWith('/package.json'), packageJsonPath); // package.json#exports["package.json"] may point to another file than package.json
+    return packageJsonPath;
+}
+exports.getDependencyPackageJsonPath = getDependencyPackageJsonPath;
+function resolvePackageJsonDirectly(npmPackageName, userAppRootDir) {
+    let packageJsonPath;
+    try {
+        packageJsonPath = require_.resolve(`${npmPackageName}/package.json`, { paths: [userAppRootDir] });
+    }
+    catch (err) {
+        if (isUnexpectedError(err))
+            throw err;
+        return null;
+    }
+    return packageJsonPath;
+}
+function resolvePackageJsonWithMainEntry(npmPackageName, userAppRootDir) {
+    let mainEntry;
+    try {
+        mainEntry = require_.resolve(npmPackageName, { paths: [userAppRootDir] });
+    }
+    catch (err) {
+        if (isUnexpectedError(err))
+            throw err;
+        return null;
+    }
+    const packageJsonPath = searchPackageJSON(mainEntry);
+    return packageJsonPath;
+}
+// If the npm package doesn't define package.json#exports then require.resolve(`${npmPackageName}/package.json`) just works.
+// This means we can assume packageJson#exports to be defined and, consequently, we can assume the error code to always be ERR_PACKAGE_PATH_NOT_EXPORTED.
+// (If MODULE_NOT_FOUND is thrown then this means that npmPackageName isn't installed.)
+function isUnexpectedError(err) {
+    return err?.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED';
+}
+// Copied and adapted from https://github.com/antfu/local-pkg
+function searchPackageJSON(dir) {
+    let packageJsonPath;
+    while (true) {
+        (0, assert_js_1.assert)(dir);
+        const newDir = path_1.default.dirname(dir);
+        (0, assert_js_1.assert)(newDir !== dir);
+        dir = newDir;
+        packageJsonPath = path_1.default.join(dir, 'package.json');
+        if (fs_1.default.existsSync(packageJsonPath))
+            return packageJsonPath;
+    }
+}

package/dist/cjs/utils/getFileExtension.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileExtension = void 0;
+const slice_js_1 = require("./slice.js");
+function getFileExtension(id) {
+    id = id.split('?')[0];
+    const fileName = (0, slice_js_1.slice)(id.split('/'), -1, 0)[0];
+    if (!fileName) {
+        return null;
+    }
+    const fileExtension = (0, slice_js_1.slice)(fileName.split('.'), -1, 0)[0];
+    if (!fileExtension) {
+        return null;
+    }
+    return fileExtension;
+}
+exports.getFileExtension = getFileExtension;

package/dist/cjs/utils/getFilePathAbsolute.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilePathRelativeToUserRootDir = exports.getFilePathAbsolute = void 0;
+const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
+const assert_js_1 = require("./assert.js");
+const path_1 = __importDefault(require("path"));
+const assertIsNotProductionRuntime_js_1 = require("./assertIsNotProductionRuntime.js");
+const isNpmPackage_js_1 = require("./isNpmPackage.js");
+const assertPathIsFilesystemAbsolute_js_1 = require("./assertPathIsFilesystemAbsolute.js");
+const module_1 = require("module");
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = `file://${__filename}`;
+const require_ = (0, module_1.createRequire)(importMetaUrl);
+(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+// Vite handles paths such as /pages/index.page.js which are relative to `config.root`.
+// Make them absolute starting from the filesystem root.
+// Also resolve plus files living in npm packages such as restack/renderer/+onRenderHtml.js
+function getFilePathAbsolute(filePath, config) {
+    (0, filesystemPathHandling_js_1.assertPosixPath)(filePath);
+    if (filePath.startsWith('/@fs/')) {
+        return filePath;
+    }
+    let filePathUnresolved;
+    if ((0, isNpmPackage_js_1.isNpmPackageImport)(filePath)) {
+        filePathUnresolved = filePath;
+    }
+    else {
+        (0, assert_js_1.assert)(filePath.startsWith('/'));
+        const { root } = config;
+        (0, assertPathIsFilesystemAbsolute_js_1.assertPathIsFilesystemAbsolute)(root);
+        filePathUnresolved = path_1.default.posix.join(root, filePath);
+        (0, assertPathIsFilesystemAbsolute_js_1.assertPathIsFilesystemAbsolute)(filePathUnresolved);
+    }
+    let filePathAbsolute;
+    try {
+        filePathAbsolute = require_.resolve(filePathUnresolved, { paths: [config.root] });
+    }
+    catch (err) {
+        console.error(err);
+        (0, assert_js_1.assert)(false);
+    }
+    filePathAbsolute = (0, filesystemPathHandling_js_1.toPosixPath)(filePathAbsolute);
+    (0, assertPathIsFilesystemAbsolute_js_1.assertPathIsFilesystemAbsolute)(filePathAbsolute);
+    return filePathAbsolute;
+}
+exports.getFilePathAbsolute = getFilePathAbsolute;
+function getFilePathRelativeToUserRootDir(filePathAbsolute, userRootDir, alwaysRelative = false) {
+    (0, filesystemPathHandling_js_1.assertPosixPath)(filePathAbsolute);
+    (0, filesystemPathHandling_js_1.assertPosixPath)(userRootDir);
+    let filePathRelativeToUserRootDir = path_1.default.posix.relative(userRootDir, filePathAbsolute);
+    if (filePathAbsolute.startsWith(userRootDir)) {
+        (0, assert_js_1.assert)(!filePathRelativeToUserRootDir.startsWith('.') && !filePathRelativeToUserRootDir.startsWith('/'), 
+        // Surprinsingly, this assertion seem to fail sometimes: https://github.com/vikejs/vike/issues/1139
+        { filePathRelativeToUserRootDir, filePathAbsolute, userRootDir });
+        filePathRelativeToUserRootDir = `/${filePathRelativeToUserRootDir}`;
+        return filePathRelativeToUserRootDir;
+    }
+    else {
+        if (alwaysRelative) {
+            return filePathRelativeToUserRootDir;
+        }
+        else {
+            return filePathAbsolute;
+        }
+    }
+}
+exports.getFilePathRelativeToUserRootDir = getFilePathRelativeToUserRootDir;

package/dist/cjs/utils/getGlobalObject.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalObject = void 0;
+function getGlobalObject(
+// We use the filename as key; each `getGlobalObject()` call should live in a unique filename.
+key, defaultValue) {
+    const allGlobalObjects = (globalThis.__vike = globalThis.__vike || {});
+    const globalObject = (allGlobalObjects[key] = allGlobalObjects[key] || defaultValue);
+    return globalObject;
+}
+exports.getGlobalObject = getGlobalObject;

package/dist/cjs/utils/getMostSimilar.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMostSimilar = void 0;
+const assert_js_1 = require("./assert.js");
+const sorter_js_1 = require("./sorter.js");
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+function getMostSimilar(word, words) {
+    if (words.length === 0)
+        return null;
+    const exactMatch = words.find((w) => w === word);
+    if (exactMatch)
+        return exactMatch;
+    const lowerCaseMatch = words.find((w) => w.toLowerCase() === word.toLowerCase());
+    if (lowerCaseMatch)
+        return lowerCaseMatch;
+    const mostSimilar = words
+        .map((w) => ({
+        word: w,
+        similarity: getSimilarity(w, word)
+    }))
+        .sort((0, sorter_js_1.higherFirst)(({ similarity }) => similarity))[0];
+    (0, assert_js_1.assert)(mostSimilar);
+    if (mostSimilar.similarity >= 0.8) {
+        return mostSimilar.word;
+    }
+    else {
+        return null;
+    }
+}
+exports.getMostSimilar = getMostSimilar;
+// https://stackoverflow.com/questions/10473745/compare-strings-javascript-return-of-likely/36566052#36566052
+function getSimilarity(s1, s2) {
+    var longer = s1;
+    var shorter = s2;
+    if (s1.length < s2.length) {
+        longer = s2;
+        shorter = s1;
+    }
+    var longerLength = longer.length;
+    if (longerLength == 0) {
+        return 1.0;
+    }
+    return (longerLength - editDistance(longer, shorter)) / longerLength;
+}
+function editDistance(s1, s2) {
+    s1 = s1.toLowerCase();
+    s2 = s2.toLowerCase();
+    var costs = new Array();
+    for (var i = 0; i <= s1.length; i++) {
+        var lastValue = i;
+        for (var j = 0; j <= s2.length; j++) {
+            if (i == 0)
+                costs[j] = j;
+            else {
+                if (j > 0) {
+                    var newValue = costs[j - 1];
+                    if (s1.charAt(i - 1) != s2.charAt(j - 1))
+                        newValue = Math.min(Math.min(newValue, lastValue), costs[j]) + 1;
+                    costs[j - 1] = lastValue;
+                    lastValue = newValue;
+                }
+            }
+        }
+        if (i > 0)
+            costs[s2.length] = lastValue;
+    }
+    return costs[s2.length];
+}

package/dist/cjs/utils/getOutDirs.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOutDir = exports.getOutDirs_prerender = exports.getOutDirs = void 0;
+const viteIsSSR_js_1 = require("./viteIsSSR.js");
+const assert_js_1 = require("./assert.js");
+const path_shim_js_1 = require("./path-shim.js");
+const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function getOutDirs(config) {
+    const outDir = getOutDirFromResolvedConfig(config);
+    assertOutDirResolved(outDir, config);
+    (0, assert_js_1.assert)(outDir.endsWith('/server') || outDir.endsWith('/client'));
+    (0, assert_js_1.assert)('/client'.length === '/server'.length);
+    const outDirRoot = outDir.slice(0, -1 * '/client'.length);
+    return getOutDirsAll(outDirRoot, config.root);
+}
+exports.getOutDirs = getOutDirs;
+function getOutDirs_prerender(config) {
+    const outDirRoot = getOutDirFromResolvedConfig(config);
+    (0, assert_js_1.assert)(isOutDirRoot(outDirRoot));
+    return getOutDirsAll(outDirRoot, config.root);
+}
+exports.getOutDirs_prerender = getOutDirs_prerender;
+/** Appends `client/` or `server/` to `config.build.outDir` */
+function resolveOutDir(config) {
+    const outDir = getOutDirFromUserConfig(config) || 'dist';
+    // outDir may already be resolved when using Telefunc + vike (because both Telefunc and vike use this logic)
+    if (!isOutDirRoot(outDir)) {
+        assertOutDirResolved(outDir, config);
+        return outDir;
+    }
+    else {
+        const { outDirClient, outDirServer } = determineOutDirs(outDir);
+        if ((0, viteIsSSR_js_1.viteIsSSR)(config)) {
+            return outDirServer;
+        }
+        else {
+            return outDirClient;
+        }
+    }
+}
+exports.resolveOutDir = resolveOutDir;
+function determineOutDirs(outDirRoot) {
+    (0, filesystemPathHandling_js_1.assertPosixPath)(outDirRoot);
+    (0, assert_js_1.assert)(isOutDirRoot(outDirRoot));
+    const outDirClient = (0, path_shim_js_1.pathJoin)(outDirRoot, 'client');
+    const outDirServer = (0, path_shim_js_1.pathJoin)(outDirRoot, 'server');
+    assertIsNotOutDirRoot(outDirClient);
+    assertIsNotOutDirRoot(outDirServer);
+    return { outDirClient, outDirServer };
+}
+function getOutDirsAll(outDirRoot, root) {
+    if (!outDirIsAbsolutePath(outDirRoot)) {
+        (0, filesystemPathHandling_js_1.assertPosixPath)(outDirRoot);
+        (0, filesystemPathHandling_js_1.assertPosixPath)(root);
+        outDirRoot = (0, path_shim_js_1.pathJoin)(root, outDirRoot);
+    }
+    let { outDirClient, outDirServer } = determineOutDirs(outDirRoot);
+    outDirRoot = outDirRoot + '/';
+    outDirClient = outDirClient + '/';
+    outDirServer = outDirServer + '/';
+    assertNormalization(outDirRoot);
+    assertNormalization(outDirClient);
+    assertNormalization(outDirServer);
+    return { outDirRoot, outDirClient, outDirServer };
+}
+function assertNormalization(outDirAny) {
+    (0, filesystemPathHandling_js_1.assertPosixPath)(outDirAny);
+    (0, assert_js_1.assert)(outDirIsAbsolutePath(outDirAny));
+    (0, assert_js_1.assert)(outDirAny.endsWith('/'));
+    (0, assert_js_1.assert)(!outDirAny.endsWith('//'));
+}
+function isOutDirRoot(outDirRot) {
+    const p = outDirRot.split('/').filter(Boolean);
+    const lastDir = p[p.length - 1];
+    return lastDir !== 'client' && lastDir !== 'server';
+}
+function assertIsNotOutDirRoot(outDir) {
+    (0, assert_js_1.assert)(outDir.endsWith('/client') || outDir.endsWith('/server'));
+}
+/** `outDir` ends with `/server` or `/client` */
+function assertOutDirResolved(outDir, config) {
+    (0, filesystemPathHandling_js_1.assertPosixPath)(outDir);
+    assertIsNotOutDirRoot(outDir);
+    (0, assert_js_1.assert)('/client'.length === '/server'.length);
+    const outDirCorrected = outDir.slice(0, -1 * '/client'.length);
+    const wrongUsage = `You've set Vite's config.build.outDir to ${picocolors_1.default.cyan(outDir)} but you should set it to ${picocolors_1.default.cyan(outDirCorrected)} instead.`;
+    if ((0, viteIsSSR_js_1.viteIsSSR)(config)) {
+        (0, assert_js_1.assertUsage)(outDir.endsWith('/server'), wrongUsage);
+    }
+    else {
+        (0, assert_js_1.assertUsage)(outDir.endsWith('/client'), wrongUsage);
+    }
+}
+function getOutDirFromUserConfig(config) {
+    let outDir = config.build?.outDir;
+    if (outDir === undefined)
+        return undefined;
+    // I believe Vite normalizes config.build.outDir only if config is ResolvedConfig
+    outDir = (0, filesystemPathHandling_js_1.toPosixPath)(outDir);
+    return outDir;
+}
+function getOutDirFromResolvedConfig(config) {
+    let outDir = config.build.outDir;
+    // Vite seems to be buggy and doesn't always normalize config.build.outDir
+    outDir = (0, filesystemPathHandling_js_1.toPosixPath)(outDir);
+    return outDir;
+}
+function outDirIsAbsolutePath(outDir) {
+    // There doesn't seem to be a better alternative to determine whether `outDir` is an aboslute path
+    //  - Very unlikely that `outDir`'s first dir macthes the filesystem's first dir
+    //    - Although more likely to happen with Docker
+    return getFirstDir(outDir) === getFirstDir(process.cwd());
+}
+function getFirstDir(p) {
+    const firstDir = p.split(/\/|\\/).filter(Boolean)[0];
+    return firstDir;
+}

package/dist/cjs/utils/getPropAccessNotation.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropAccessNotation = void 0;
+function getPropAccessNotation(key) {
+    return isKeyDotNotationCompatible(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
+}
+exports.getPropAccessNotation = getPropAccessNotation;
+function isKeyDotNotationCompatible(key) {
+    return /^[a-z0-9\$_]+$/i.test(key);
+}

package/dist/cjs/utils/getRandomId.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRandomId = void 0;
+const assert_js_1 = require("./assert.js");
+// https://stackoverflow.com/questions/1349404/generate-random-string-characters-in-javascript
+function getRandomId(length) {
+    let randomId = '';
+    while (randomId.length < length) {
+        randomId += Math.random().toString(36).slice(2);
+    }
+    randomId = randomId.slice(0, length);
+    (0, assert_js_1.assert)(/^[a-z0-9]+$/.test(randomId) && randomId.length === length);
+    return randomId;
+}
+exports.getRandomId = getRandomId;