@hyperdreamer/pi-webui 1.15.2 → 1.16.0

package/dist/pi-webui-plugins/workspace-tasks/workspaceTasksClient.js

@@ -1,242 +0,0 @@
-// Generated from pi-webui-plugins/workspace-tasks/workspaceTasksClient.ts. Do not edit directly.
-import { TASKS_CONFIG_PATH, parseTasksConfigText, serializeWorkspaceTasksConfig, } from "./config.js";
-export const tasksConfigMissingMessage = "No workspace tasks configured here.";
-export const tasksConfigMissingHint = `${TASKS_CONFIG_PATH} is optional. Create it in this workspace if you want custom tasks.`;
-export const tasksConfigInvalidMessage = "Workspace tasks configuration is invalid.";
-export const tasksConfigInvalidHint = `Fix ${TASKS_CONFIG_PATH}, then click Refresh.`;
-export const tasksConfigUnavailableMessage = "Could not load workspace tasks.";
-export const tasksConfigRefreshHint = `Fix ${TASKS_CONFIG_PATH}, then click Refresh.`;
-const configCache = new Map();
-const workspaceRuntimes = new Map();
-const subscribers = new Set();
-let stateEpoch = 0;
-export function loadWorkspaceTasksConfig(files) {
-    return readCurrentWorkspaceTasksConfig(files);
-}
-export function getWorkspaceTasksCacheEntry(workspaceKey) {
-    return configCache.get(workspaceKey);
-}
-export function ensureWorkspaceTasksConfig(files, workspaceKey) {
-    const cached = configCache.get(workspaceKey);
-    if (cached !== undefined)
-        return cached;
-    const runtime = getWorkspaceRuntime(workspaceKey);
-    const loadingEntry = {
-        state: { kind: "loading" },
-        refreshRequired: runtime.refreshRequired,
-    };
-    configCache.set(workspaceKey, loadingEntry);
-    void enqueueWorkspaceOperation(workspaceKey, async (operation) => {
-        const state = await loadWorkspaceTasksConfigSafely(files);
-        if (state.kind === "unavailable")
-            operation.runtime.refreshRequired = true;
-        publishState(operation, state, operation.runtime.refreshRequired);
-    }).catch(() => undefined);
-    return loadingEntry;
-}
-export function refreshWorkspaceTasksConfig(files, workspaceKey) {
-    return enqueueWorkspaceOperation(workspaceKey, async (operation) => {
-        const state = await loadWorkspaceTasksConfigSafely(files);
-        operation.runtime.refreshRequired = state.kind === "unavailable";
-        publishState(operation, state, operation.runtime.refreshRequired);
-        return state;
-    }, (operation) => {
-        if (!isCurrentOperation(operation))
-            return;
-        configCache.set(workspaceKey, {
-            state: { kind: "loading" },
-            refreshRequired: operation.runtime.refreshRequired,
-        });
-    });
-}
-export function guardedWriteWorkspaceTasksConfig(files, workspaceKey, sourceSnapshot, nextConfig) {
-    return enqueueWorkspaceOperation(workspaceKey, async (operation) => {
-        if (operation.runtime.refreshRequired) {
-            return blockMutation(operation, "A successful Refresh is required before another workspace task mutation.");
-        }
-        const preflight = await loadWorkspaceTasksConfigSafely(files);
-        if (preflight.kind === "unavailable") {
-            return blockMutation(operation, unavailableDetail(preflight));
-        }
-        const currentSnapshot = preflight.snapshot;
-        if (!snapshotsEqual(sourceSnapshot, currentSnapshot)) {
-            return blockMutation(operation, `The ${TASKS_CONFIG_PATH} file changed outside this panel. Refresh before trying again.`, "conflict");
-        }
-        const payload = serializeWorkspaceTasksConfig(nextConfig);
-        try {
-            await files.writeFile(TASKS_CONFIG_PATH, payload);
-        }
-        catch (error) {
-            return blockMutation(operation, `Unable to write ${TASKS_CONFIG_PATH}: ${formatUnknownError(error)}`, "write-failed");
-        }
-        const postWrite = await loadWorkspaceTasksConfigSafely(files);
-        if (postWrite.kind === "loaded" && postWrite.snapshot.content === payload) {
-            operation.runtime.refreshRequired = false;
-            publishState(operation, postWrite, false);
-            return { kind: "written", state: postWrite };
-        }
-        const detail = postWriteReloadDetail(postWrite);
-        blockMutation(operation, detail, undefined, postWrite);
-        return { kind: "written-but-unreloaded", detail };
-    });
-}
-export function subscribeWorkspaceTasksConfig(listener) {
-    subscribers.add(listener);
-    return () => {
-        subscribers.delete(listener);
-    };
-}
-export function clearWorkspaceTasksStateForTesting() {
-    stateEpoch += 1;
-    configCache.clear();
-    workspaceRuntimes.clear();
-}
-async function readCurrentWorkspaceTasksConfig(files) {
-    let file;
-    try {
-        file = await files.readFile(TASKS_CONFIG_PATH);
-    }
-    catch (error) {
-        if (isMissingWorkspaceFileError(error))
-            return missing();
-        return unavailable(`Unable to read ${TASKS_CONFIG_PATH}: ${formatUnknownError(error)}`);
-    }
-    if (file.binary)
-        return unavailable(`${TASKS_CONFIG_PATH} must be a text file`);
-    if (file.truncated)
-        return unavailable(`${TASKS_CONFIG_PATH} is too large and was truncated`);
-    const result = parseTasksConfigText(file.content);
-    if (!result.ok) {
-        return {
-            kind: "invalid",
-            message: tasksConfigInvalidMessage,
-            hint: tasksConfigInvalidHint,
-            detail: result.error,
-            snapshot: { kind: "text", content: file.content },
-        };
-    }
-    return {
-        kind: "loaded",
-        config: result.config,
-        path: TASKS_CONFIG_PATH,
-        snapshot: { kind: "text", content: file.content },
-    };
-}
-async function loadWorkspaceTasksConfigSafely(files) {
-    try {
-        return await readCurrentWorkspaceTasksConfig(files);
-    }
-    catch (error) {
-        return unavailable(`Unable to read ${TASKS_CONFIG_PATH}: ${formatUnknownError(error)}`);
-    }
-}
-function enqueueWorkspaceOperation(workspaceKey, operation, onRequest) {
-    const runtime = getWorkspaceRuntime(workspaceKey);
-    const context = {
-        key: workspaceKey,
-        runtime,
-        generation: runtime.requestGeneration + 1,
-        epoch: stateEpoch,
-    };
-    runtime.requestGeneration = context.generation;
-    onRequest?.(context);
-    const result = runtime.tail.then(() => operation(context));
-    runtime.tail = result.then(() => undefined, () => undefined);
-    return result;
-}
-function getWorkspaceRuntime(workspaceKey) {
-    const existing = workspaceRuntimes.get(workspaceKey);
-    if (existing !== undefined)
-        return existing;
-    const runtime = {
-        requestGeneration: 0,
-        refreshRequired: false,
-        tail: Promise.resolve(),
-    };
-    workspaceRuntimes.set(workspaceKey, runtime);
-    return runtime;
-}
-function publishState(operation, state, refreshRequired) {
-    if (!isCurrentOperation(operation))
-        return;
-    configCache.set(operation.key, { state, refreshRequired });
-    notifySubscribers(operation.key);
-}
-function blockMutation(operation, detail, kind = "preflight-unavailable", postWriteState) {
-    operation.runtime.refreshRequired = true;
-    if (isCurrentOperation(operation)) {
-        const existing = configCache.get(operation.key);
-        if (postWriteState !== undefined) {
-            configCache.set(operation.key, { state: postWriteState, refreshRequired: true });
-        }
-        else if (existing !== undefined) {
-            configCache.set(operation.key, { ...existing, refreshRequired: true });
-        }
-        notifySubscribers(operation.key);
-    }
-    return { kind, detail };
-}
-function isCurrentOperation(operation) {
-    return operation.epoch === stateEpoch
-        && workspaceRuntimes.get(operation.key) === operation.runtime
-        && operation.runtime.requestGeneration === operation.generation;
-}
-function notifySubscribers(workspaceKey) {
-    for (const listener of subscribers)
-        listener(workspaceKey);
-}
-function snapshotsEqual(left, right) {
-    if (left.kind !== right.kind)
-        return false;
-    if (left.kind === "missing" || right.kind === "missing")
-        return true;
-    return left.content === right.content;
-}
-function postWriteReloadDetail(result) {
-    if (result.kind === "loaded")
-        return `Unable to reload ${TASKS_CONFIG_PATH}: the post-write snapshot did not match the canonical payload.`;
-    if (result.kind === "missing")
-        return `Unable to reload ${TASKS_CONFIG_PATH}: the file is missing after the write.`;
-    if (result.kind === "invalid")
-        return `Unable to reload ${TASKS_CONFIG_PATH}: ${result.detail}`;
-    return `Unable to reload ${TASKS_CONFIG_PATH}: ${unavailableDetail(result)}`;
-}
-function missing() {
-    return {
-        kind: "missing",
-        message: tasksConfigMissingMessage,
-        hint: tasksConfigMissingHint,
-        snapshot: { kind: "missing" },
-    };
-}
-function unavailable(detail) {
-    return {
-        kind: "unavailable",
-        message: tasksConfigUnavailableMessage,
-        hint: tasksConfigRefreshHint,
-        detail,
-    };
-}
-function unavailableDetail(result) {
-    return result.detail ?? tasksConfigUnavailableMessage;
-}
-function isMissingWorkspaceFileError(error) {
-    const message = errorField(error, "message");
-    const code = errorField(error, "code");
-    return message === "Path does not exist"
-        || code?.toLowerCase() === "enoent"
-        || message?.toLowerCase() === "enoent"
-        || message?.toLowerCase().includes("no such file or directory") === true
-        || code?.toLowerCase().includes("no such file or directory") === true;
-}
-function errorField(error, field) {
-    if (typeof error === "object" && error !== null && hasStringField(error, field))
-        return error[field];
-    return error instanceof Error && field === "message" ? error.message : undefined;
-}
-function hasStringField(value, field) {
-    return field in value && typeof Reflect.get(value, field) === "string";
-}
-function formatUnknownError(error) {
-    return error instanceof Error ? error.message : String(error);
-}