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

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

@@ -1,80 +0,0 @@
-/**
- * 调试约定的两个相位：`debugging` 正占着用户的屏，`paused` 已暂停但仍持着约定。
- */
-export type DebugPhase = 'debugging' | 'paused';
-/**
- * 调试约定收得下的三个人话动作：暂停 / 继续 / 结束。
- */
-export type DebugIntent = 'pause' | 'resume' | 'stop';
-/**
- * 把工具入参收成人话动作。
- * @param value - 任意入参值。
- * @returns `'pause'` / `'resume'` / `'stop'` 原样；别的值（含 `undefined`、多余空白、大小写不同）给 `null`，由调用方拒。
- */
-export declare function parseDebugIntent(value: unknown): DebugIntent | null;
-/**
- * 调试约定的有效期（4 小时，毫秒）：超过它没动静的约定算过期、当场让人。
- */
-export declare const DEBUG_STALE_MS: number;
-/**
- * 一份活着的调试约定：相位 + 谁的会话 + 哪个工作区 / 板 / 单元 + 起于何时（`at` 是最后一次动作）。
- */
-export interface DebugState {
-    readonly phase: DebugPhase;
-    readonly sessionId: string;
-    readonly workspacePath: string;
-    readonly title: string;
-    readonly board: string;
-    readonly unit: string;
-    readonly name: string;
-    readonly startedAt: number;
-    readonly at: number;
-}
-/**
- * 建立约定要交的那几件：会话、工作区、板、单元、名字，以及此刻的时间戳。
- */
-export interface DebugPact {
-    readonly sessionId: string;
-    readonly workspacePath: string;
-    readonly title: string;
-    readonly board: string;
-    readonly unit: string;
-    readonly name: string;
-    readonly now: number;
-}
-/**
- * 约定被拒的原因码：自己已持有 / 别人持着 / 不是持有者 / 没有约定 / 已暂停 / 已在调试。
- */
-export type DebugRefusal = 'already-held' | 'held-by-other' | 'not-owner' | 'none' | 'already-paused' | 'already-debugging';
-/**
- * 一次约定动作的结果：成功带新状态，失败带拒绝码。
- */
-export type DebugMove = {
-    readonly ok: true;
-    readonly state: DebugState;
-} | {
-    readonly ok: false;
-    readonly code: DebugRefusal;
-};
-/**
- * 调试约定的存取口（外壳持有一份）：`live` 取当前有效的约定，`begin` / `pause` / `resume` / `stop` 推相位。
- */
-export interface DebugStore {
-    live(now: number): DebugState | null;
-    begin(pact: DebugPact): DebugMove;
-    pause(sessionId: string, now: number): DebugMove;
-    resume(sessionId: string, now: number): DebugMove;
-    stop(sessionId: string, now: number): DebugMove;
-    settle?(): Promise<void>;
-}
-/**
- * 造一份新的调试约定存储（进程内存，同一时刻只可能有一份有效约定）。
- * @returns 存取口；动作成不成都在返回的 `DebugMove` 里，不抛异常。
- */
-export declare function createDebugStore(): DebugStore;
-/**
- * 「谁还占着」的一句话，用于别人来抢时说清现况。
- * @param state - 当前有效的那份约定。
- * @returns 形如「会话 x（自 HH:mm:ssZ 起在调试 y）」的中文串。
- */
-export declare function debugOwnerText(state: DebugState): string;

package/dist/lib/diy-debug.js

@@ -1,88 +0,0 @@
-/**
- * 把工具入参收成人话动作。
- * @param value - 任意入参值。
- * @returns `'pause'` / `'resume'` / `'stop'` 原样；别的值（含 `undefined`、多余空白、大小写不同）给 `null`，由调用方拒。
- */
-export function parseDebugIntent(value) {
-    return value === 'pause' || value === 'resume' || value === 'stop' ? value : null;
-}
-/**
- * 调试约定的有效期（4 小时，毫秒）：超过它没动静的约定算过期、当场让人。
- */
-export const DEBUG_STALE_MS = 4 * 60 * 60 * 1000;
-function alive(state, now) {
-    if (state === null)
-        return null;
-    return now - state.at <= DEBUG_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 存取口；动作成不成都在返回的 `DebugMove` 里，不抛异常。
- */
-export function createDebugStore() {
-    let held = null;
-    const live = (now) => alive(held, 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: 'debugging',
-                sessionId: pact.sessionId,
-                workspacePath: pact.workspacePath,
-                title: pact.title,
-                board: pact.board,
-                unit: pact.unit,
-                name: pact.name,
-                startedAt: pact.now,
-                at: pact.now,
-            };
-            held = state;
-            return { ok: true, state };
-        },
-        pause(sessionId, now) {
-            const found = ownerOf(held, sessionId, now);
-            if (typeof found === 'string')
-                return { ok: false, code: found };
-            if (found.phase === 'paused')
-                return { ok: false, code: 'already-paused' };
-            const state = { ...found, phase: 'paused', at: now };
-            held = state;
-            return { ok: true, state };
-        },
-        resume(sessionId, now) {
-            const found = ownerOf(held, sessionId, now);
-            if (typeof found === 'string')
-                return { ok: false, code: found };
-            if (found.phase === 'debugging')
-                return { ok: false, code: 'already-debugging' };
-            const state = { ...found, phase: 'debugging', 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 debugOwnerText(state) {
-    return `会话 ${state.sessionId}（自 ${new Date(state.startedAt).toISOString().slice(11, 19)}Z 起在调试 ${state.unit}）`;
-}

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;