@dsh-workbench/shared 0.3.11 → 1.0.0-beta.0

package/dist/lib/diy-record.d.ts

@@ -1,135 +0,0 @@
-/**
- * 录制交接的三个相位：`armed` 等用户在外站页面上动手，`recording` 正在录，`finished` 录完待取。
- */
-export type RecordPhase = 'armed' | 'recording' | 'finished';
-/**
- * 录制约定的有效期（15 分钟，毫秒）：超过它没动静的约定算过期、当场让人。
- */
-export declare const RECORD_STALE_MS: number;
-/**
- * 这次录制要找的那一次写：HTTP 方法 + URL 里必须含的一段（不填就是只认方法）。
- */
-export interface RecordExpect {
-    readonly method: string;
-    readonly urlContains: string;
-}
-/**
- * 一次「截图」在宿主台账里的那一行：页面上的计数、落图那一刻、落盘路径；没落下来时带 `error` 原文（落成的那条没有它）。
- */
-export interface RecordShot {
-    readonly n: number;
-    readonly at: number;
-    readonly path: string;
-    readonly error?: string;
-}
-/**
- * 某个页面计数已经试过几次：初拍算一次，失败再试一次；计数一换就从头数。
- */
-export interface RecordShotTries {
-    readonly n: number;
-    readonly tries: number;
-}
-/**
- * 一张图最多试几次（初拍 + 一次重试）：失败如实报过就停，不每拍重试到底。
- */
-export declare const RECORD_SHOT_TRIES = 2;
-/**
- * 一份活着的录制约定：相位 + 谁的会话 + 哪个工作区 / 单元 + 页面 URL 与标题 + 要找的那一次写 +
- * 落盘文件 + 三个时间戳，以及两份台账：按计数落图的 `shots`（`shotsSeen` 只记落成的那个计数）
- * 与门铃的 `beats` / `beatMs`（命中几次、最近一次等了多久）。
- */
-export interface RecordState {
-    readonly phase: RecordPhase;
-    readonly sessionId: string;
-    readonly workspace: string;
-    readonly unit: string;
-    readonly name: string;
-    readonly url: string;
-    readonly title: string;
-    readonly action: string;
-    readonly expect: RecordExpect | null;
-    readonly captureFile: string;
-    readonly startedAt: number;
-    readonly t0: number | null;
-    readonly t1: number | null;
-    readonly shots: readonly RecordShot[];
-    readonly shotsSeen: number;
-    readonly shotTries: RecordShotTries | null;
-    readonly beats: number;
-    readonly beatMs: number;
-    readonly at: number;
-}
-/**
- * 开一次录制要交的那几件：会话、工作区、单元、名字、页面 URL 与标题、动作名、期望、落盘文件，以及此刻时间。
- */
-export interface RecordPact {
-    readonly sessionId: string;
-    readonly workspace: string;
-    readonly unit: string;
-    readonly name: string;
-    readonly url: string;
-    readonly title: string;
-    readonly action: string;
-    readonly expect: RecordExpect | null;
-    readonly captureFile: string;
-    readonly now: number;
-}
-/**
- * 录制被拒的原因码：自己已持有 / 别人持着 / 不是持有者 / 没有约定 / 已在录 / 还没 arm / 不在录 / 还没录完。
- */
-export type RecordRefusal = 'already-held' | 'held-by-other' | 'not-owner' | 'none' | 'already-recording' | 'not-armed' | 'not-recording' | 'not-finished';
-/**
- * 一次录制动作的结果：成功带新状态，失败带拒绝码。
- */
-export type RecordMove = {
-    readonly ok: true;
-    readonly state: RecordState;
-} | {
-    readonly ok: false;
-    readonly code: RecordRefusal;
-};
-/**
- * 录制约定收得下的三个人话动作：看看进度 / 停手 / 结束并取回。
- */
-export type RecordIntent = 'peek' | 'halt' | 'stop';
-/**
- * 把工具入参收成人话动作。
- * @param raw - 任意入参值。
- * @returns `'peek'` / `'halt'` / `'stop'` 原样；别的值（含 `undefined`、多余空白）给 `null`，由调用方拒。
- */
-export declare function parseRecordIntent(raw: unknown): RecordIntent | null;
-/**
- * 录制约定的存取口（外壳持有一份）：相位随 `begin → started → finished` 推进，`release` 是收尾时放掉浏览器那一跳。
- */
-export interface RecordStore {
-    readonly release?: ((state: RecordState) => Promise<{
-        readonly tab: boolean;
-        readonly capture: boolean;
-    }>) | undefined;
-    live(now: number): RecordState | null;
-    begin(pact: RecordPact): RecordMove;
-    started(sessionId: string, at: number, now: number): RecordMove;
-    finished(sessionId: string, at: number, now: number): RecordMove;
-    shotTaken(sessionId: string, shot: RecordShot, now: number): RecordMove;
-    shotFailed(sessionId: string, shot: RecordShot, now: number): RecordMove;
-    beat(sessionId: string, ms: number, now: number): RecordMove;
-    stop(sessionId: string, now: number): RecordMove;
-}
-/**
- * 这一拍该不该落图：页面计数涨过 `shotsSeen` 才算；同一个计数已经试满就先放下，等他自己再按。
- * @param state - 当前有效的那份约定。
- * @param pageShots - 页面浮条上那个「已拍」计数。
- * @returns 该落的那个计数；不该落给 `null`（没涨 / 试满了 / 不是个正经数）。
- */
-export declare function shotDueOf(state: RecordState, pageShots: number): number | null;
-/**
- * 造一份新的录制约定存储（进程内存，同一时刻只可能有一份有效约定）。
- * @returns 存取口；动作成不成都在返回的 `RecordMove` 里，不抛异常。
- */
-export declare function createRecordStore(): RecordStore;
-/**
- * 「谁还占着、在录哪个动作」的一句话，用于别人来抢时说清现况。
- * @param state - 当前有效的那份约定。
- * @returns 形如「会话 x（自 HH:mm:ssZ 起在录 y 的「动作」）」的中文串。
- */
-export declare function recordOwnerText(state: RecordState): string;

package/dist/lib/diy-record.js

@@ -1,162 +0,0 @@
-/**
- * 录制约定的有效期（15 分钟，毫秒）：超过它没动静的约定算过期、当场让人。
- */
-export const RECORD_STALE_MS = 15 * 60 * 1000;
-/**
- * 一张图最多试几次（初拍 + 一次重试）：失败如实报过就停，不每拍重试到底。
- */
-export const RECORD_SHOT_TRIES = 2;
-/**
- * 把工具入参收成人话动作。
- * @param raw - 任意入参值。
- * @returns `'peek'` / `'halt'` / `'stop'` 原样；别的值（含 `undefined`、多余空白）给 `null`，由调用方拒。
- */
-export function parseRecordIntent(raw) {
-    return raw === 'peek' || raw === 'halt' || raw === 'stop' ? raw : null;
-}
-/**
- * 这一拍该不该落图：页面计数涨过 `shotsSeen` 才算；同一个计数已经试满就先放下，等他自己再按。
- * @param state - 当前有效的那份约定。
- * @param pageShots - 页面浮条上那个「已拍」计数。
- * @returns 该落的那个计数；不该落给 `null`（没涨 / 试满了 / 不是个正经数）。
- */
-export function shotDueOf(state, pageShots) {
-    if (!Number.isFinite(pageShots))
-        return null;
-    const n = Math.floor(pageShots);
-    if (n <= state.shotsSeen)
-        return null;
-    if (state.shotTries !== null && state.shotTries.n === n && state.shotTries.tries >= RECORD_SHOT_TRIES)
-        return null;
-    return n;
-}
-function alive(state, now) {
-    if (state === null)
-        return null;
-    return now - state.at <= RECORD_STALE_MS ? state : null;
-}
-function ownerOf(state, sessionId, now) {
-    const held = alive(state, now);
-    if (held === null)
-        return 'none';
-    return held.sessionId === sessionId ? held : 'not-owner';
-}
-/**
- * 造一份新的录制约定存储（进程内存，同一时刻只可能有一份有效约定）。
- * @returns 存取口；动作成不成都在返回的 `RecordMove` 里，不抛异常。
- */
-export function createRecordStore() {
-    let held = null;
-    const live = (now) => alive(held, now);
-    const withShot = (found, shot, now, error) => {
-        const row = error === undefined ? shot : { n: shot.n, at: shot.at, path: shot.path, error };
-        const kept = found.shots.filter((one) => one.n !== shot.n);
-        const tries = found.shotTries !== null && found.shotTries.n === shot.n ? found.shotTries.tries : 0;
-        return {
-            ...found,
-            shots: [...kept, row].sort((one, two) => one.n - two.n),
-            shotsSeen: error === undefined ? Math.max(found.shotsSeen, shot.n) : found.shotsSeen,
-            shotTries: error === undefined ? null : { n: shot.n, tries: tries + 1 },
-            at: now,
-        };
-    };
-    return {
-        live,
-        begin(pact) {
-            const current = alive(held, pact.now);
-            if (current !== null) {
-                return { ok: false, code: current.sessionId === pact.sessionId ? 'already-held' : 'held-by-other' };
-            }
-            const state = {
-                phase: 'armed',
-                sessionId: pact.sessionId,
-                workspace: pact.workspace,
-                unit: pact.unit,
-                name: pact.name,
-                url: pact.url,
-                title: pact.title,
-                action: pact.action,
-                expect: pact.expect,
-                captureFile: pact.captureFile,
-                startedAt: pact.now,
-                t0: null,
-                t1: null,
-                shots: [],
-                shotsSeen: 0,
-                shotTries: null,
-                beats: 0,
-                beatMs: 0,
-                at: pact.now,
-            };
-            held = state;
-            return { ok: true, state };
-        },
-        started(sessionId, at, now) {
-            const found = ownerOf(held, sessionId, now);
-            if (typeof found === 'string')
-                return { ok: false, code: found };
-            if (found.phase === 'recording')
-                return { ok: false, code: 'already-recording' };
-            if (found.phase !== 'armed')
-                return { ok: false, code: 'not-armed' };
-            const state = { ...found, phase: 'recording', t0: at, at: now };
-            held = state;
-            return { ok: true, state };
-        },
-        finished(sessionId, at, now) {
-            const found = ownerOf(held, sessionId, now);
-            if (typeof found === 'string')
-                return { ok: false, code: found };
-            if (found.phase !== 'recording')
-                return { ok: false, code: 'not-recording' };
-            const state = { ...found, phase: 'finished', t1: at, at: now };
-            held = state;
-            return { ok: true, state };
-        },
-        shotTaken(sessionId, shot, now) {
-            const found = ownerOf(held, sessionId, now);
-            if (typeof found === 'string')
-                return { ok: false, code: found };
-            const state = withShot(found, shot, now, undefined);
-            held = state;
-            return { ok: true, state };
-        },
-        shotFailed(sessionId, shot, now) {
-            const found = ownerOf(held, sessionId, now);
-            if (typeof found === 'string')
-                return { ok: false, code: found };
-            const state = withShot(found, shot, now, shot.error === undefined ? '落图失败' : shot.error);
-            held = state;
-            return { ok: true, state };
-        },
-        beat(sessionId, ms, now) {
-            const found = ownerOf(held, sessionId, now);
-            if (typeof found === 'string')
-                return { ok: false, code: found };
-            const state = {
-                ...found,
-                beats: found.beats + 1,
-                beatMs: Math.max(0, Math.floor(ms)),
-                at: now,
-            };
-            held = state;
-            return { ok: true, state };
-        },
-        stop(sessionId, now) {
-            const found = ownerOf(held, sessionId, now);
-            if (typeof found === 'string')
-                return { ok: false, code: found };
-            held = null;
-            return { ok: true, state: found };
-        },
-    };
-}
-/**
- * 「谁还占着、在录哪个动作」的一句话，用于别人来抢时说清现况。
- * @param state - 当前有效的那份约定。
- * @returns 形如「会话 x（自 HH:mm:ssZ 起在录 y 的「动作」）」的中文串。
- */
-export function recordOwnerText(state) {
-    const at = new Date(state.startedAt).toISOString().slice(11, 19);
-    return `会话 ${state.sessionId}（自 ${at}Z 起在录 ${state.unit} 的「${state.action}」）`;
-}

package/dist/lib/lint-probe.d.ts

@@ -1 +0,0 @@
-export declare function useLintProbe(): number;

package/dist/lib/lint-probe.js

@@ -1,6 +0,0 @@
-import { useRef } from './react';
-export function useLintProbe() {
-    const probeRef = useRef(0);
-    probeRef.current = 1;
-    return probeRef.current;
-}

package/dist/lib/panel-state.d.ts

@@ -1,120 +0,0 @@
-/**
- * 一张面板卡片取数走到哪一步：`idle` 还没取、`loading` 取着、`ready` 拿到了、`error` 失败了。
- */
-export type PanelCardPhase = 'idle' | 'loading' | 'ready' | 'error';
-/**
- * 一次取数失败：机器码 + 给人看的一句话。
- */
-export interface PanelCardError {
-    readonly code: string;
-    readonly message: string;
-}
-/**
- * 一张卡片最近一次取数的读数：哪个单元、哪条路由、什么相位、什么时候、失败原因。
- */
-export interface PanelCardRead {
-    readonly unit: string;
-    readonly route: string;
-    readonly phase: PanelCardPhase;
-    readonly at: number;
-    readonly error?: PanelCardError;
-}
-/**
- * 一张卡片崩了的读数：单元、原因、时间，以及同一原因连着崩了几次（窗口见 `PANEL_STATE_CRASH_WINDOW_MS`）。
- */
-export interface PanelCardCrash {
-    readonly unit: string;
-    readonly reason: string;
-    readonly at: number;
-    readonly count: number;
-}
-/**
- * 一个单元此刻的读数：它的卡片、最近一次读成的时间（`okAt`，没成过给 `null`），以及崩了的那一条。
- */
-export interface PanelUnitReport {
-    readonly unit: string;
-    readonly at: number;
-    readonly okAt: number | null;
-    readonly cards: readonly PanelCardRead[];
-    readonly crash?: PanelCardCrash;
-}
-/**
- * 一个工作区此刻的全量读数（面板按工作区存）：所有单元的读数 + 整块最近动过的时间。
- */
-export interface PanelWorkspaceReport {
-    readonly workspace: string | null;
-    readonly at: number;
-    readonly units: readonly PanelUnitReport[];
-}
-/**
- * 客户端往上报的一批卡片读数（`POST` 请求体的形状）。
- */
-export interface PanelCardsReport {
-    readonly workspace: string;
-    readonly cards: readonly PanelCardRead[];
-}
-/**
- * 客户端往上报的一次卡片崩溃（`POST` 请求体的形状）。
- */
-export interface PanelCrashReport {
-    readonly workspace: string;
-    readonly unit: string;
-    readonly reason: string;
-    readonly at: number;
-}
-/**
- * 面板运行态的留存口（宿主持有一份）：收卡片读数与崩溃，按工作区取快照。
- */
-export interface PanelStateStore {
-    cards(report: PanelCardsReport): void;
-    crash(report: PanelCrashReport): void;
-    snapshot(workspace: string | null): PanelWorkspaceReport;
-}
-/**
- * 留存的工作区上限（LRU，满 64 个丢最旧的）。
- */
-export declare const PANEL_STATE_MAX_UNITS = 64;
-/**
- * 每个单元留存的卡片上限（按路由 LRU，满 12 张丢最旧的）。
- */
-export declare const PANEL_STATE_MAX_CARDS = 12;
-/**
- * 一次上报最多读入的卡片条数（32 条之后的丢掉）。
- */
-export declare const PANEL_STATE_MAX_REPORTS = 32;
-/**
- * 同一原因的连续崩溃算进同一次计数的窗口（10 分钟，毫秒）。
- */
-export declare const PANEL_STATE_CRASH_WINDOW_MS = 600000;
-/**
- * 上报文本字段的截断长度（2000 字符；workspace / reason / message 共用）。
- */
-export declare const PANEL_STATE_MAX_TEXT = 2000;
-/**
- * 上报解析的结果：`ok: true` 带收好的值，`ok: false` 带一句中文原因（直接回给上报方）。
- */
-export type PanelParse<T> = {
-    readonly ok: true;
-    readonly value: T;
-} | {
-    readonly ok: false;
-    readonly message: string;
-};
-/**
- * 收一批卡片读数上报。
- * @param payload - `POST` 的请求体。
- * @returns 至少收到一条能认的卡片才 `ok: true`；请求体不是对象、`workspace` 为空、`cards` 不是数组，
- *   或一条都认不出（`unit` / `route` / `phase` / `at` 缺一）时 `ok: false` + 中文原因；认不出的单条静默跳过。
- */
-export declare function parseCardsReport(payload: unknown): PanelParse<PanelCardsReport>;
-/**
- * 收一次卡片崩溃上报。
- * @param payload - `POST` 的请求体。
- * @returns `workspace` / `unit` / `reason` 都不能空，缺一给 `ok: false` + 中文原因；`at` 缺省或不合法时取当前时间。
- */
-export declare function parseCrashReport(payload: unknown): PanelParse<PanelCrashReport>;
-/**
- * 造一份面板运行态的留存（进程内存、按工作区分桶，带上面那几条上限的 LRU）。
- * @returns 留存口：`cards` / `crash` 收上报，`snapshot(workspace)` 取全量；没存过的工作区（含 `null`）给一份空的。
- */
-export declare function createPanelStateStore(): PanelStateStore;

package/dist/lib/panel-state.js

@@ -1,176 +0,0 @@
-/**
- * 留存的工作区上限（LRU，满 64 个丢最旧的）。
- */
-export const PANEL_STATE_MAX_UNITS = 64;
-/**
- * 每个单元留存的卡片上限（按路由 LRU，满 12 张丢最旧的）。
- */
-export const PANEL_STATE_MAX_CARDS = 12;
-/**
- * 一次上报最多读入的卡片条数（32 条之后的丢掉）。
- */
-export const PANEL_STATE_MAX_REPORTS = 32;
-/**
- * 同一原因的连续崩溃算进同一次计数的窗口（10 分钟，毫秒）。
- */
-export const PANEL_STATE_CRASH_WINDOW_MS = 600000;
-/**
- * 上报文本字段的截断长度（2000 字符；workspace / reason / message 共用）。
- */
-export const PANEL_STATE_MAX_TEXT = 2000;
-const PHASES = ['idle', 'loading', 'ready', 'error'];
-function asRecord(value) {
-    return typeof value === 'object' && value !== null ? value : undefined;
-}
-function textOf(value, max) {
-    if (typeof value !== 'string')
-        return '';
-    const trimmed = value.trim();
-    return trimmed.length > max ? trimmed.slice(0, max) : trimmed;
-}
-function atOf(value) {
-    if (typeof value !== 'number' || !Number.isFinite(value))
-        return null;
-    if (value < 0)
-        return null;
-    return Math.trunc(value);
-}
-function errorOf(raw) {
-    const record = asRecord(raw);
-    if (record === undefined)
-        return undefined;
-    const code = textOf(record['code'], 120);
-    const message = textOf(record['message'], PANEL_STATE_MAX_TEXT);
-    if (code === '' && message === '')
-        return undefined;
-    return { code: code === '' ? 'unknown' : code, message };
-}
-/**
- * 收一批卡片读数上报。
- * @param payload - `POST` 的请求体。
- * @returns 至少收到一条能认的卡片才 `ok: true`；请求体不是对象、`workspace` 为空、`cards` 不是数组，
- *   或一条都认不出（`unit` / `route` / `phase` / `at` 缺一）时 `ok: false` + 中文原因；认不出的单条静默跳过。
- */
-export function parseCardsReport(payload) {
-    const record = asRecord(payload);
-    if (record === undefined)
-        return { ok: false, message: '请求体要是一个对象' };
-    const workspace = textOf(record['workspace'], PANEL_STATE_MAX_TEXT);
-    if (workspace === '')
-        return { ok: false, message: 'workspace 不能是空的 —— 面板按工作区存' };
-    const raw = record['cards'];
-    if (!Array.isArray(raw))
-        return { ok: false, message: 'cards 要是一个数组' };
-    const cards = [];
-    for (const item of raw.slice(0, PANEL_STATE_MAX_REPORTS)) {
-        const card = asRecord(item);
-        if (card === undefined)
-            continue;
-        const unit = textOf(card['unit'], 200);
-        const route = textOf(card['route'], 400);
-        const phase = textOf(card['phase'], 20);
-        const at = atOf(card['at']);
-        if (unit === '' || route === '' || at === null || !PHASES.includes(phase))
-            continue;
-        const error = errorOf(card['error']);
-        cards.push({ unit, route, phase, at, ...(error === undefined ? {} : { error }) });
-    }
-    if (cards.length === 0)
-        return { ok: false, message: 'cards 里没有一条能认的（unit / route / phase / at 都要有）' };
-    return { ok: true, value: { workspace, cards } };
-}
-/**
- * 收一次卡片崩溃上报。
- * @param payload - `POST` 的请求体。
- * @returns `workspace` / `unit` / `reason` 都不能空，缺一给 `ok: false` + 中文原因；`at` 缺省或不合法时取当前时间。
- */
-export function parseCrashReport(payload) {
-    const record = asRecord(payload);
-    if (record === undefined)
-        return { ok: false, message: '请求体要是一个对象' };
-    const workspace = textOf(record['workspace'], PANEL_STATE_MAX_TEXT);
-    const unit = textOf(record['unit'], 200);
-    const reason = textOf(record['reason'], PANEL_STATE_MAX_TEXT);
-    if (workspace === '')
-        return { ok: false, message: 'workspace 不能是空的' };
-    if (unit === '')
-        return { ok: false, message: 'unit 不能是空的' };
-    if (reason === '')
-        return { ok: false, message: 'reason 不能是空的（没有原因的崩溃没法查）' };
-    return { ok: true, value: { workspace, unit, reason, at: atOf(record['at']) ?? Date.now() } };
-}
-/**
- * 造一份面板运行态的留存（进程内存、按工作区分桶，带上面那几条上限的 LRU）。
- * @returns 留存口：`cards` / `crash` 收上报，`snapshot(workspace)` 取全量；没存过的工作区（含 `null`）给一份空的。
- */
-export function createPanelStateStore() {
-    const workspaces = new Map();
-    function trim(entry, max) {
-        while (entry.size > max) {
-            const oldest = entry.keys().next();
-            if (oldest.done === true)
-                return;
-            entry.delete(oldest.value);
-        }
-    }
-    function workspaceEntryOf(workspace) {
-        const existing = workspaces.get(workspace);
-        if (existing !== undefined)
-            return existing;
-        const created = { at: 0, units: new Map() };
-        workspaces.set(workspace, created);
-        trim(workspaces, PANEL_STATE_MAX_UNITS);
-        return created;
-    }
-    function unitEntryOf(entry, unit) {
-        const existing = entry.units.get(unit);
-        if (existing !== undefined)
-            return existing;
-        const created = { at: 0, cards: new Map() };
-        entry.units.set(unit, created);
-        return created;
-    }
-    return {
-        cards(report) {
-            const entry = workspaceEntryOf(report.workspace);
-            for (const card of report.cards) {
-                const unit = unitEntryOf(entry, card.unit);
-                unit.cards.delete(card.route);
-                unit.cards.set(card.route, card);
-                trim(unit.cards, PANEL_STATE_MAX_CARDS);
-                if (card.at > unit.at)
-                    unit.at = card.at;
-                if (card.at > entry.at)
-                    entry.at = card.at;
-            }
-        },
-        crash(report) {
-            const entry = workspaceEntryOf(report.workspace);
-            const unit = unitEntryOf(entry, report.unit);
-            const previous = unit.crash;
-            const counted = previous !== undefined &&
-                previous.reason === report.reason &&
-                report.at >= previous.at &&
-                report.at - previous.at <= PANEL_STATE_CRASH_WINDOW_MS;
-            unit.crash = { unit: report.unit, reason: report.reason, at: report.at, count: counted ? previous.count + 1 : 1 };
-            if (report.at > unit.at)
-                unit.at = report.at;
-            if (report.at > entry.at)
-                entry.at = report.at;
-        },
-        snapshot(workspace) {
-            if (workspace === null)
-                return { workspace: null, at: 0, units: [] };
-            const entry = workspaces.get(workspace);
-            if (entry === undefined)
-                return { workspace, at: 0, units: [] };
-            const units = [...entry.units.entries()].map(([unit, one]) => {
-                const cards = [...one.cards.values()].sort((a, b) => a.route.localeCompare(b.route));
-                const okAt = cards.reduce((best, card) => (card.phase === 'ready' && (best === null || card.at > best) ? card.at : best), null);
-                return { unit, at: one.at, okAt, cards, ...(one.crash === undefined ? {} : { crash: one.crash }) };
-            });
-            units.sort((a, b) => b.at - a.at || a.unit.localeCompare(b.unit));
-            return { workspace, at: entry.at, units };
-        },
-    };
-}

package/src/api/__tests__/unit.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { hasEnvSupply, type UnitManifest } from '../unit.js';
-
-function manifest(env?: UnitManifest['env']): UnitManifest {
-  return {
-    id: 'issues',
-    card: { titleKey: 'issues.mine', order: 10 },
-    tools: [],
-    host: { inject: [] },
-    ...(env === undefined ? {} : { env }),
-  };
-}
-
-describe('hasEnvSupply（缺来源时那条回退口径，宿主与浏览器共用一份）', () => {
-  it('声明了插件或库 → 有供给', () => {
-    expect(hasEnvSupply(manifest({ plugins: [{ name: 'coding', commands: ['x'] }] }))).toBe(true);
-    expect(
-      hasEnvSupply(
-        manifest({
-          libs: [
-            {
-              name: 'opencli-workflow',
-              registryEnv: 'WB_NPM',
-              registryDefault: 'https://registry.example/',
-              purpose: '夹具',
-            },
-          ],
-        }),
-      ),
-    ).toBe(true);
-  });
-
-  it('★ 只有基座命令（无卡片模块那种）不算供给 —— 它不是市场门槛，只是缺来源时的回退', () => {
-    expect(hasEnvSupply(manifest({ command: 'gitops' }))).toBe(false);
-    expect(hasEnvSupply(manifest({ plugins: [], libs: [] }))).toBe(false);
-    expect(hasEnvSupply(manifest())).toBe(false);
-  });
-});