@bleedingdev/modern-js-create 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

package/dist/cjs/ultramodern-workspace/add-vertical/transaction.cjs

@@ -0,0 +1,327 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DEFAULT_STALE_LOCK_MS: ()=>DEFAULT_STALE_LOCK_MS,
+    ULTRAMODERN_LOCK_DIRECTORY: ()=>ULTRAMODERN_LOCK_DIRECTORY,
+    ULTRAMODERN_LOCK_FILE: ()=>ULTRAMODERN_LOCK_FILE,
+    WorkspaceLockIntegrityError: ()=>WorkspaceLockIntegrityError,
+    WorkspaceLockedError: ()=>WorkspaceLockedError,
+    __releaseTestHooks: ()=>__releaseTestHooks,
+    captureWorkspaceBackup: ()=>captureWorkspaceBackup,
+    restoreWorkspaceBackup: ()=>restoreWorkspaceBackup,
+    runWorkspaceTransaction: ()=>runWorkspaceTransaction
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_generation_result_cjs_namespaceObject = require("../generation-result.cjs");
+const external_naming_cjs_namespaceObject = require("../naming.cjs");
+function walkWorkspaceFiles(root, onFile) {
+    if (!external_node_fs_default().existsSync(root)) return;
+    const collect = (currentDir)=>{
+        for (const entry of external_node_fs_default().readdirSync(currentDir, {
+            withFileTypes: true
+        })){
+            if (entry.isDirectory() && external_generation_result_cjs_namespaceObject.ignoredSnapshotDirectories.has(entry.name)) continue;
+            const entryPath = external_node_path_default().join(currentDir, entry.name);
+            if (entry.isDirectory()) collect(entryPath);
+            else if (entry.isFile()) onFile((0, external_naming_cjs_namespaceObject.normalizePath)(external_node_path_default().relative(root, entryPath)), entryPath);
+        }
+    };
+    collect(root);
+}
+function captureWorkspaceBackup(root) {
+    const files = new Map();
+    walkWorkspaceFiles(root, (relativePath, absolutePath)=>{
+        let content;
+        try {
+            content = external_node_fs_default().readFileSync(absolutePath);
+        } catch (error) {
+            if ('ENOENT' === error.code) return;
+            throw error;
+        }
+        files.set(relativePath, content);
+    });
+    return {
+        root,
+        files
+    };
+}
+function listCurrentFiles(root) {
+    const current = [];
+    walkWorkspaceFiles(root, (relativePath)=>{
+        current.push(relativePath);
+    });
+    return current;
+}
+function pruneEmptyDirectories(root, relativeFilePath) {
+    let directory = external_node_path_default().dirname(external_node_path_default().join(root, relativeFilePath));
+    const stopAt = external_node_path_default().resolve(root);
+    while(external_node_path_default().resolve(directory) !== stopAt){
+        let entries;
+        try {
+            entries = external_node_fs_default().readdirSync(directory);
+        } catch  {
+            return;
+        }
+        if (entries.length > 0) return;
+        external_node_fs_default().rmdirSync(directory);
+        directory = external_node_path_default().dirname(directory);
+    }
+}
+function restoreWorkspaceBackup(backup) {
+    for (const relativePath of listCurrentFiles(backup.root))if (!backup.files.has(relativePath)) {
+        external_node_fs_default().rmSync(external_node_path_default().join(backup.root, relativePath), {
+            force: true
+        });
+        pruneEmptyDirectories(backup.root, relativePath);
+    }
+    for (const [relativePath, content] of backup.files){
+        const absolutePath = external_node_path_default().join(backup.root, relativePath);
+        if (!(external_node_fs_default().existsSync(absolutePath) && external_node_fs_default().readFileSync(absolutePath).equals(content))) {
+            external_node_fs_default().mkdirSync(external_node_path_default().dirname(absolutePath), {
+                recursive: true
+            });
+            external_node_fs_default().writeFileSync(absolutePath, content);
+        }
+    }
+}
+const ULTRAMODERN_LOCK_DIRECTORY = '.modernjs';
+const ULTRAMODERN_LOCK_FILE = '.ultramodern-mutation.lock';
+const DEFAULT_STALE_LOCK_MS = 30000;
+class WorkspaceLockedError extends Error {
+    constructor(message){
+        super(message), this.code = 'workspace-locked';
+        this.name = 'WorkspaceLockedError';
+    }
+}
+class WorkspaceLockIntegrityError extends Error {
+    constructor(message, options){
+        super(message), this.code = 'workspace-lock-integrity';
+        this.name = 'WorkspaceLockIntegrityError';
+        if (options?.cause !== void 0) this.cause = options.cause;
+    }
+}
+function lockFilePath(root) {
+    return external_node_path_default().join(root, ULTRAMODERN_LOCK_DIRECTORY, ULTRAMODERN_LOCK_FILE);
+}
+function parseLock(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (null === parsed || 'object' != typeof parsed) return;
+        const record = parsed;
+        if ('string' != typeof record.token || 'number' != typeof record.pid || !Number.isFinite(record.pid) || 'number' != typeof record.createdAt || !Number.isFinite(record.createdAt)) return;
+        return {
+            token: record.token,
+            pid: record.pid,
+            createdAt: record.createdAt
+        };
+    } catch  {
+        return;
+    }
+}
+function readLockObservation(lockPath) {
+    try {
+        const raw = external_node_fs_default().readFileSync(lockPath, 'utf-8');
+        return {
+            raw,
+            record: parseLock(raw)
+        };
+    } catch  {
+        return;
+    }
+}
+function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch (error) {
+        const code = error.code;
+        if ('ESRCH' === code) return false;
+        if ('EPERM' === code) return true;
+        return;
+    }
+}
+function writeLock(lockPath, record) {
+    try {
+        external_node_fs_default().writeFileSync(lockPath, JSON.stringify(record), {
+            flag: 'wx'
+        });
+        return true;
+    } catch (error) {
+        if ('EEXIST' === error.code) return false;
+        throw error;
+    }
+}
+function unlinkIfPresent(filePath) {
+    try {
+        external_node_fs_default().unlinkSync(filePath);
+    } catch (error) {
+        if ('ENOENT' !== error.code) throw error;
+    }
+}
+function restoreMovedLock(movedLockPath, lockPath) {
+    try {
+        external_node_fs_default().linkSync(movedLockPath, lockPath);
+    } catch (error) {
+        const code = error.code;
+        if ('EPERM' === code || 'EOPNOTSUPP' === code || 'ENOTSUP' === code) {
+            try {
+                external_node_fs_default().copyFileSync(movedLockPath, lockPath, external_node_fs_default().constants.COPYFILE_EXCL);
+            } catch (copyError) {
+                throw new WorkspaceLockIntegrityError(`Failed to restore moved workspace lock ${movedLockPath} -> ${lockPath}; moved lock bytes left in place for recovery.`, {
+                    cause: copyError
+                });
+            }
+            unlinkIfPresent(movedLockPath);
+            return;
+        }
+        throw new WorkspaceLockIntegrityError(`Failed to restore moved workspace lock ${movedLockPath} -> ${lockPath}; moved lock bytes left in place for recovery.`, {
+            cause: error
+        });
+    }
+    unlinkIfPresent(movedLockPath);
+}
+function workspaceLockedError(root) {
+    return new WorkspaceLockedError(`Workspace at ${root} is locked by another ultramodern mutation.`);
+}
+function isStaleLock(observation, staleLockMs) {
+    if (void 0 === observation.record) return true;
+    const age = Date.now() - observation.record.createdAt;
+    return age > staleLockMs || false === isProcessAlive(observation.record.pid);
+}
+function takeOverLock(lockPath, observed, replacement) {
+    const takeoverPath = `${lockPath}.takeover.${replacement.token}`;
+    try {
+        external_node_fs_default().renameSync(lockPath, takeoverPath);
+    } catch (error) {
+        if ('ENOENT' === error.code) return false;
+        throw error;
+    }
+    const claimed = readLockObservation(takeoverPath);
+    if (void 0 === claimed || '' === claimed.raw || claimed.raw !== observed.raw) {
+        restoreMovedLock(takeoverPath, lockPath);
+        return false;
+    }
+    try {
+        return writeLock(lockPath, replacement);
+    } finally{
+        unlinkIfPresent(takeoverPath);
+    }
+}
+function acquireWorkspaceLock(root, staleLockMs) {
+    const lockPath = lockFilePath(root);
+    external_node_fs_default().mkdirSync(external_node_path_default().dirname(lockPath), {
+        recursive: true
+    });
+    const record = {
+        token: (0, external_node_crypto_namespaceObject.randomUUID)(),
+        pid: process.pid,
+        createdAt: Date.now()
+    };
+    if (writeLock(lockPath, record)) return {
+        lockPath,
+        token: record.token
+    };
+    const observed = readLockObservation(lockPath);
+    if (void 0 === observed) throw workspaceLockedError(root);
+    const age = void 0 === observed.record ? void 0 : Date.now() - observed.record.createdAt;
+    if (!isStaleLock(observed, staleLockMs)) throw workspaceLockedError(root);
+    process.emitWarning(`Taking over stale ultramodern workspace lock at ${lockPath} (age ${age ?? 'unknown'}ms).`);
+    if (takeOverLock(lockPath, observed, record)) return {
+        lockPath,
+        token: record.token
+    };
+    throw workspaceLockedError(root);
+}
+const __releaseTestHooks = {};
+function releaseWorkspaceLock(handle) {
+    const inPlace = readLockObservation(handle.lockPath);
+    if (inPlace?.record?.token !== handle.token) return;
+    __releaseTestHooks.afterOwnershipRead?.(handle);
+    const releasePath = `${handle.lockPath}.release.${handle.token}`;
+    try {
+        external_node_fs_default().renameSync(handle.lockPath, releasePath);
+    } catch (error) {
+        if ('ENOENT' === error.code) return;
+        throw error;
+    }
+    const moved = readLockObservation(releasePath);
+    if (moved?.record?.token === handle.token) return void unlinkIfPresent(releasePath);
+    __releaseTestHooks.beforeRestore?.(handle);
+    restoreMovedLock(releasePath, handle.lockPath);
+}
+function runWorkspaceTransaction(root, mutate, options) {
+    const lock = acquireWorkspaceLock(root, options?.staleLockMs ?? DEFAULT_STALE_LOCK_MS);
+    const backup = captureWorkspaceBackup(root);
+    try {
+        return mutate();
+    } catch (error) {
+        restoreWorkspaceBackup(backup);
+        throw error;
+    } finally{
+        releaseWorkspaceLock(lock);
+    }
+}
+exports.DEFAULT_STALE_LOCK_MS = __webpack_exports__.DEFAULT_STALE_LOCK_MS;
+exports.ULTRAMODERN_LOCK_DIRECTORY = __webpack_exports__.ULTRAMODERN_LOCK_DIRECTORY;
+exports.ULTRAMODERN_LOCK_FILE = __webpack_exports__.ULTRAMODERN_LOCK_FILE;
+exports.WorkspaceLockIntegrityError = __webpack_exports__.WorkspaceLockIntegrityError;
+exports.WorkspaceLockedError = __webpack_exports__.WorkspaceLockedError;
+exports.__releaseTestHooks = __webpack_exports__.__releaseTestHooks;
+exports.captureWorkspaceBackup = __webpack_exports__.captureWorkspaceBackup;
+exports.restoreWorkspaceBackup = __webpack_exports__.restoreWorkspaceBackup;
+exports.runWorkspaceTransaction = __webpack_exports__.runWorkspaceTransaction;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_STALE_LOCK_MS",
+    "ULTRAMODERN_LOCK_DIRECTORY",
+    "ULTRAMODERN_LOCK_FILE",
+    "WorkspaceLockIntegrityError",
+    "WorkspaceLockedError",
+    "__releaseTestHooks",
+    "captureWorkspaceBackup",
+    "restoreWorkspaceBackup",
+    "runWorkspaceTransaction"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/add-vertical/workspace-state.cjs

@@ -0,0 +1,137 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    assertCanCreate: ()=>assertCanCreate,
+    assertGlobalPortUniqueness: ()=>assertGlobalPortUniqueness,
+    assertValidVerticalName: ()=>assertValidVerticalName,
+    configuredDevelopmentPorts: ()=>configuredDevelopmentPorts,
+    existingBridgeConfig: ()=>existingBridgeConfig,
+    existingPackageSource: ()=>existingPackageSource,
+    existingTailwindEnabled: ()=>existingTailwindEnabled,
+    nextAvailablePort: ()=>nextAvailablePort
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const config_cjs_namespaceObject = require("../../ultramodern-tooling/config.cjs");
+const external_descriptors_cjs_namespaceObject = require("../descriptors.cjs");
+const external_naming_cjs_namespaceObject = require("../naming.cjs");
+const external_package_source_cjs_namespaceObject = require("../package-source.cjs");
+const external_constants_cjs_namespaceObject = require("./constants.cjs");
+function existingPackageSource(workspaceRoot, modernVersion, packageSource) {
+    if (packageSource) return (0, external_package_source_cjs_namespaceObject.resolvePackageSource)({
+        targetDir: workspaceRoot,
+        packageName: external_node_path_default().basename(workspaceRoot),
+        modernVersion,
+        packageSource
+    });
+    const compactPath = external_node_path_default().join(workspaceRoot, external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH);
+    if (external_node_fs_default().existsSync(compactPath)) {
+        const compactConfig = (0, config_cjs_namespaceObject.readUltramodernConfig)(workspaceRoot);
+        if (compactConfig.packageSource) return compactConfig.packageSource;
+    }
+    throw new Error(`Missing UltraModern workspace file: ${compactPath}`);
+}
+function existingTailwindEnabled(workspaceRoot) {
+    const compactPath = external_node_path_default().join(workspaceRoot, external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH);
+    if (external_node_fs_default().existsSync(compactPath)) return (0, config_cjs_namespaceObject.readUltramodernConfig)(workspaceRoot).features.tailwind;
+    throw new Error(`Missing UltraModern workspace file: ${compactPath}`);
+}
+function existingBridgeConfig(workspaceRoot) {
+    const compactPath = external_node_path_default().join(workspaceRoot, external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH);
+    return external_node_fs_default().existsSync(compactPath) ? (0, config_cjs_namespaceObject.readUltramodernConfig)(workspaceRoot).bridge : void 0;
+}
+function assertValidVerticalName(name) {
+    const normalized = (0, external_naming_cjs_namespaceObject.toKebabCase)(name);
+    if (!normalized || normalized !== name) throw new Error(`Invalid Vertical name "${name}". Use lowercase kebab-case.`);
+    return normalized;
+}
+function configuredDevelopmentPorts(ports, additionalShells = []) {
+    return [
+        ...new Set([
+            ...Object.values(ports),
+            ...additionalShells.map((shell)=>shell.port)
+        ].filter((value)=>'number' == typeof value && Number.isFinite(value)))
+    ];
+}
+function assertGlobalPortUniqueness(ports, additionalShells = []) {
+    const owners = new Map();
+    for (const [id, value] of Object.entries(ports)){
+        if ('number' != typeof value || !Number.isFinite(value)) continue;
+        const previous = owners.get(value);
+        if (previous) throw new Error(`Duplicate development port "${value}" for ${previous} and ${id}.`);
+        owners.set(value, id);
+    }
+    for (const shell of additionalShells){
+        const previous = owners.get(shell.port);
+        if (previous) throw new Error(`Duplicate development port "${shell.port}" for ${previous} and ${shell.id}.`);
+        owners.set(shell.port, shell.id);
+    }
+}
+function nextAvailablePort(ports, additionalShells = [], minimumPort = external_constants_cjs_namespaceObject.FIRST_VERTICAL_PORT) {
+    const used = new Set(configuredDevelopmentPorts(ports, additionalShells));
+    let candidate = minimumPort;
+    while(used.has(candidate))candidate += 1;
+    return candidate;
+}
+function assertCanCreate(workspaceRoot, relativePath) {
+    if (external_node_fs_default().existsSync(external_node_path_default().join(workspaceRoot, relativePath))) throw new Error(`Refusing to overwrite existing path: ${relativePath}`);
+}
+exports.assertCanCreate = __webpack_exports__.assertCanCreate;
+exports.assertGlobalPortUniqueness = __webpack_exports__.assertGlobalPortUniqueness;
+exports.assertValidVerticalName = __webpack_exports__.assertValidVerticalName;
+exports.configuredDevelopmentPorts = __webpack_exports__.configuredDevelopmentPorts;
+exports.existingBridgeConfig = __webpack_exports__.existingBridgeConfig;
+exports.existingPackageSource = __webpack_exports__.existingPackageSource;
+exports.existingTailwindEnabled = __webpack_exports__.existingTailwindEnabled;
+exports.nextAvailablePort = __webpack_exports__.nextAvailablePort;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "assertCanCreate",
+    "assertGlobalPortUniqueness",
+    "assertValidVerticalName",
+    "configuredDevelopmentPorts",
+    "existingBridgeConfig",
+    "existingPackageSource",
+    "existingTailwindEnabled",
+    "nextAvailablePort"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});