rowvia 0.2.4 → 0.3.1

package/dist/types/features/sideBar.d.ts

@@ -1,8 +1,5 @@
-import type { Grid } from '../grid';
-export interface ToolPanelDef {
-    id: string;
-    label: string;
-}
+export type { ToolPanelDef } from '../core/gridHost';
+import type { GridHost as Grid } from '../core/gridHost';
 export declare class SideBarService {
     private grid;
     private eBar;

package/dist/types/features/sortService.d.ts

@@ -1,5 +1,5 @@
+import type { GridHost as Grid } from '../core/gridHost';
 import type { Column, SortDirection, SortModelItem } from '../types';
-import type { Grid } from '../grid';
 export declare class SortService {
     private grid;
     constructor(grid: Grid);

package/dist/types/features/statusBar.d.ts

@@ -1,11 +1,10 @@
-import type { Grid } from '../grid';
 import type { EventService } from '../core/eventService';
+import type { GridHost as Grid } from '../core/gridHost';
 export declare class StatusBarService {
     private grid;
-    private eventService;
     private eBar;
     private panels;
-    constructor(grid: Grid, eventService: EventService);
+    constructor(grid: Grid, _eventService: EventService);
     getElement(): HTMLElement;
     isVisible(): boolean;
     setVisible(visible: boolean): void;

package/dist/types/features/undoRedoService.d.ts

@@ -1,13 +1,6 @@
-import type { Grid } from '../grid';
+export type { UndoRedoAction } from '../core/gridHost';
 import type { EventService } from '../core/eventService';
-export interface UndoRedoAction {
-    rowNodeId: string;
-    colId: string;
-    oldValue: any;
-    newValue: any;
-    /** batch id — edits committed in one batch share an id and undo together */
-    batchId: number;
-}
+import type { GridHost as Grid, UndoRedoAction } from '../core/gridHost';
 /**
  * Undo / Redo for cell edits (ag-grid undoRedoCellEditing).
  * Records every committed edit and can replay them in both directions.

package/dist/types/fields/attachment-control.d.ts

@@ -0,0 +1,2 @@
+import type { ControlContext, ControlEditor } from './types';
+export declare function attachmentEditor(c: ControlContext): ControlEditor;

package/dist/types/fields/base-field.d.ts

@@ -0,0 +1,62 @@
+import type { ControlContext, ControlEditor, FieldContent, FieldEvent, FieldListener, FieldOptions, FieldSnapshot, FieldState, FieldView } from './types';
+import { observeInteractions } from './internal/interaction';
+/** A field owns its value, three states and resources; hosts own persistence. */
+export declare abstract class BaseField {
+    private root?;
+    private destroying;
+    private feedback?;
+    protected options: FieldOptions;
+    private value;
+    private committedValue;
+    private state;
+    private view?;
+    private viewLife;
+    private readonly life;
+    private readonly listeners;
+    private interactions?;
+    private readonly interactionListeners;
+    private mounted;
+    private handled;
+    constructor(options: FieldOptions);
+    get element(): HTMLElement;
+    private bindRoot;
+    protected abstract renderDisplay(context: ControlContext): FieldView;
+    protected abstract renderEditing(context: ControlContext): ControlEditor;
+    protected renderHover(context: ControlContext): FieldView;
+    protected beforeInput(value: unknown): unknown;
+    protected beforeCommit(_event: FieldEvent): boolean;
+    protected beforeCancel(_event: FieldEvent): boolean;
+    protected beforeStateChange(_event: FieldEvent): boolean;
+    protected validateValue(_value: unknown): string | undefined;
+    protected isReadonly(): boolean;
+    protected onOutput(_event: FieldEvent): void;
+    get snapshot(): FieldSnapshot;
+    mount(container?: HTMLElement): this;
+    read(): unknown;
+    on(listener: FieldListener): () => void;
+    onInteraction(listener: Parameters<ReturnType<typeof observeInteractions>['onInteraction']>[0]): () => void;
+    input(value: unknown, source?: 'api' | 'user', originalEvent?: Event): void;
+    /** External synchronization is distinct from user input; it resets the draft. */
+    setValue(value: unknown): void;
+    update(options: Partial<FieldOptions>): void;
+    validate(): string | undefined;
+    commit(source?: 'api' | 'user'): boolean;
+    cancel(source?: 'api' | 'user'): void;
+    edit(source?: 'api' | 'user'): void;
+    setState(state: FieldState, source?: 'api' | 'user'): void;
+    action(type: string, value?: unknown): void;
+    destroy(): void;
+    /** Compatibility hosts can mount an input directly while sharing hooks/events. */
+    createEditor(): ControlEditor;
+    /** Static view resources belong to the returned handle, with no editing boundary. */
+    render(): FieldView;
+    private context;
+    private showValidation;
+    private draw;
+    private watch;
+    private disposeView;
+    private event;
+    private emit;
+    private publish;
+}
+export declare function renderContent(content: FieldContent): FieldView;

package/dist/types/{pages/work-items → fields}/cascade-control.d.ts

@@ -1,3 +1,3 @@
-import type { ControlContext, ControlEditor } from './controls';
+import type { ControlContext, ControlEditor } from './types';
 export declare function renderCascade(c: ControlContext): HTMLDivElement;
 export declare function cascadeEditor(multiple: boolean, c: ControlContext): ControlEditor;

package/dist/types/{pages/work-items → fields}/choice-control.d.ts

@@ -1,6 +1,5 @@
-import type { ControlContext, ControlEditor } from './controls';
-import type { FieldConfig, FieldOption } from './config';
-export declare const el: <K extends keyof HTMLElementTagNameMap>(tag: K, cls?: string, text?: string) => HTMLElementTagNameMap[K];
+import type { ControlContext, ControlEditor, FieldConfig, FieldOption } from './types';
+export { element as el } from './internal/dom';
 export declare const choices: (field: FieldConfig) => FieldOption[];
 export declare const color: (field: FieldConfig, id: string) => string;
 export declare function optionLabel(field: FieldConfig, id: string): string;

package/dist/types/fields/composite-control.d.ts

@@ -0,0 +1,3 @@
+import type { ControlContext, ControlEditor, FieldConfig, FieldControl } from './types';
+/** Row objects are stable identities: adding/removing siblings never remounts an input. */
+export declare function compositeEditor(context: ControlContext, resolve: (field: FieldConfig) => FieldControl): ControlEditor;

package/dist/types/fields/controls.d.ts

@@ -0,0 +1,19 @@
+import { BaseField } from './base-field';
+import type { ControlContext, ControlEditor, FieldConfig, FieldControl, FieldOptions, FieldView } from './types';
+export interface FieldDefinition extends Omit<FieldControl, 'render' | 'renderView' | 'createEditor'> {
+    create(options: FieldOptions): BaseField;
+}
+/** Composition root: subclasses never import this registry. */
+export declare function createFieldRegistry(custom?: FieldDefinition[]): {
+    register: (definition: FieldDefinition) => void;
+    resolve: (field: Pick<FieldConfig, "control" | "kind">) => FieldDefinition;
+    create: (options: FieldOptions) => BaseField;
+    list: () => FieldDefinition[];
+};
+/** Adapts caller-defined render functions without adding any domain dependency. */
+export declare class CustomField extends BaseField {
+    private readonly control;
+    constructor(options: FieldOptions, control: Pick<FieldControl, 'render' | 'createEditor'>);
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}

package/dist/types/{pages/work-items → fields}/date-control.d.ts

@@ -1,3 +1,3 @@
-import type { ControlContext, ControlEditor } from './controls';
+import type { ControlContext, ControlEditor } from './types';
 export declare function renderDate(context: ControlContext): HTMLElement;
 export declare function dateEditor(context: ControlContext): ControlEditor;

package/dist/types/fields/field-types.d.ts

@@ -0,0 +1,114 @@
+import { BaseField } from './base-field';
+import type { ControlContext, ControlEditor, FieldConfig, FieldControl, FieldOptions, FieldView } from './types';
+export declare class TextField extends BaseField {
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class NumberField extends TextField {
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class RichTextField extends TextField {
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class TextareaField extends TextField {
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class LinkField extends TextField {
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class EmailField extends TextField {
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class PhoneField extends TextField {
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class ChoiceField extends BaseField {
+    protected multiple: boolean;
+    protected variant: 'choice' | 'person' | 'relation' | 'radio';
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class MultiChoiceField extends ChoiceField {
+    protected multiple: boolean;
+}
+export declare class RadioField extends ChoiceField {
+    protected variant: "radio";
+}
+export declare class PersonField extends ChoiceField {
+    protected variant: "person";
+}
+export declare class MultiPersonField extends PersonField {
+    protected multiple: boolean;
+}
+export declare class RelationField extends ChoiceField {
+    protected variant: "relation";
+}
+export declare class MultiRelationField extends RelationField {
+    protected multiple: boolean;
+}
+export declare class CascadeField extends BaseField {
+    protected multiple: boolean;
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class MultiCascadeField extends CascadeField {
+    protected multiple: boolean;
+}
+export declare class DateTimeField extends BaseField {
+    protected normalize(context: ControlContext): ControlContext;
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class DateField extends DateTimeField {
+    protected range: boolean;
+    protected normalize(context: ControlContext): ControlContext;
+}
+export declare class DateRangeField extends DateField {
+    protected range: boolean;
+}
+export declare class SwitchField extends BaseField {
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class AttachmentField extends BaseField {
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class LocationField extends BaseField {
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class VoteField extends BaseField {
+    protected mode: 'attitude' | 'single' | 'multi';
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class SingleVoteField extends VoteField {
+    protected mode: "single";
+}
+export declare class MultiVoteField extends VoteField {
+    protected mode: "multi";
+}
+export declare class ComputedField extends BaseField {
+    protected isReadonly(): boolean;
+    constructor(options: FieldOptions);
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}
+export declare class SignalField extends ComputedField {
+    protected renderDisplay(context: ControlContext): FieldView;
+}
+export declare class ActionField extends TextField {
+    protected renderDisplay(context: ControlContext): FieldView;
+}
+/** Resolver is supplied by the composition root; never import the registry here. */
+export declare class CompositeField extends BaseField {
+    private readonly resolve;
+    constructor(options: FieldOptions, resolve: (field: FieldConfig) => FieldControl);
+    protected renderDisplay(context: ControlContext): FieldView;
+    protected renderEditing(context: ControlContext): ControlEditor;
+}

package/dist/types/fields/index.d.ts

@@ -0,0 +1,8 @@
+export { BaseField, renderContent } from './base-field';
+export * from './field-types';
+export { createFieldRegistry, CustomField } from './controls';
+export type { FieldDefinition } from './controls';
+export type * from './types';
+export { openFieldPopup, closeAllFieldPopups } from './popup';
+export type { FieldPopup, FieldPopupOptions } from './popup';
+export { sanitizeRichText } from './rich-control';

package/dist/types/fields/internal/dom.d.ts

@@ -0,0 +1 @@
+export declare function element<K extends keyof HTMLElementTagNameMap>(tag: K, className?: string, text?: string): HTMLElementTagNameMap[K];

package/dist/types/fields/internal/focus-boundary.d.ts

@@ -0,0 +1,7 @@
+/** One document listener pair, shared by all mounted editing boundaries. */
+interface Boundary {
+    contains(node: Node | null, event: Event): boolean;
+    leave(event: Event): void;
+}
+export declare function observeFocusBoundary(document: Document, boundary: Boundary): () => void;
+export {};

package/dist/types/fields/internal/interaction.d.ts

@@ -0,0 +1,23 @@
+import { type Dispose } from './lifecycle';
+export interface ComponentInteraction {
+    component: string;
+    type: string;
+    action?: string;
+    value?: string;
+    checked?: boolean;
+    /** Snapshot taken before a handler can replace the originating DOM. */
+    data: Readonly<Record<string, string>>;
+    originalEvent: Event;
+}
+export interface InteractionOptions {
+    onInteraction?: (event: ComponentInteraction) => void;
+}
+export interface InteractionSource {
+    onInteraction(listener: (event: ComponentInteraction) => void): Dispose;
+}
+/** Complements semantic callbacks with a common, non-cancelling UI event boundary. */
+export declare function observeInteractions(root: HTMLElement, component: string, options?: InteractionOptions, extraRoots?: HTMLElement[]): {
+    addRoot: (surface: HTMLElement) => Dispose;
+    onInteraction(listener: (event: ComponentInteraction) => void): Dispose;
+    destroy(): void;
+};

package/dist/types/fields/internal/lifecycle.d.ts

@@ -0,0 +1,12 @@
+export type Dispose = () => void;
+/** Owns resources for one mounted instance. Disposal is safe to repeat. */
+export declare class Lifecycle {
+    private cleanups;
+    private stopped;
+    get destroyed(): boolean;
+    add(cleanup: Dispose): Dispose;
+    listen(target: EventTarget, type: string, listener: EventListener, options?: AddEventListenerOptions | boolean): Dispose;
+    timeout(callback: () => void, delay: number): number;
+    interval(callback: () => void, delay: number): number;
+    destroy(): void;
+}

package/dist/types/fields/internal/textarea.d.ts

@@ -0,0 +1 @@
+export declare function autosizeTextarea(node: HTMLTextAreaElement, max?: number): () => void;

package/dist/types/fields/location-control.d.ts

@@ -0,0 +1,3 @@
+import type { ControlContext, ControlEditor } from './types';
+export declare function locationEditor(c: ControlContext): ControlEditor;
+export declare function renderLocation(c: ControlContext): HTMLDivElement;

package/dist/types/fields/popup.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Top-layer popup host for field controls.
+ *
+ * Feishu Project renders option lists, calendars and cascade columns in a
+ * body-level layer that floats above the page: it never joins the document
+ * flow, never changes the geometry of the field that opened it and always
+ * paints above the drawer/table below it. Rowvia reproduces that contract
+ * here so every control shares one anchor/flip/clamp implementation.
+ */
+export interface FieldPopupOptions {
+    /** Element the popup is anchored to; normally the field trigger box. */
+    anchor: HTMLElement;
+    /** Use the exact trigger for toolbar menus instead of the containing field. */
+    anchorMode?: 'element' | 'field';
+    /** Popup content, kept out of the field's DOM subtree. */
+    content: HTMLElement;
+    /** 'anchor' matches the trigger width, 'auto' hugs the content, a number sets px. */
+    width?: 'anchor' | 'auto' | number;
+    /** Vertical gap between trigger and popup; Feishu uses 4px. */
+    gap?: number;
+    /** Align wide date-range panels with the trigger's trailing edge. */
+    align?: 'start' | 'end';
+    /** Called once whenever the popup closes, including outside clicks and Esc. */
+    onDismiss?: () => void;
+    /** Override Escape's default field-collapse behavior after closing the popup. */
+    onEscape?: () => void;
+}
+export interface FieldPopup {
+    /** The body-level layer element carries the independent field style scope. */
+    element: HTMLElement;
+    reposition: () => void;
+    close: () => void;
+}
+/** True when the node belongs to any open field popup (option list, calendar, ...). */
+export declare function isInsideFieldPopup(node: Node | null, owner?: HTMLElement): boolean;
+/** Close every open field popup; hosts call this when a whole surface unmounts. */
+export declare function closeAllFieldPopups(owner?: HTMLElement): void;
+export declare function openFieldPopup(options: FieldPopupOptions): FieldPopup;

package/dist/types/{pages/work-items → fields}/rich-control.d.ts

@@ -1,4 +1,4 @@
-import type { ControlContext, ControlEditor } from './controls';
+import type { ControlContext, ControlEditor } from './types';
 /** Preserve editor formatting while dropping executable content and untrusted attributes. */
 export declare function sanitizeRichText(value: unknown): string;
 export declare function richEditor(context: ControlContext): ControlEditor;

package/dist/types/fields/text-control.d.ts

@@ -0,0 +1,3 @@
+import type { ControlContext, ControlEditor } from './types';
+export declare function renderValue(context: ControlContext): HTMLElement;
+export declare function inputEditor(type: string, context: ControlContext): ControlEditor;

package/dist/types/fields/types.d.ts

@@ -0,0 +1,185 @@
+import type { InteractionOptions, InteractionSource } from './internal/interaction';
+export interface FieldOption {
+    id: string;
+    label: string;
+    color?: string;
+    description?: string;
+    disabled?: boolean;
+    exclusive?: boolean;
+    children?: FieldOption[];
+}
+export interface AttachmentValue {
+    id: string;
+    name: string;
+    url?: string;
+    size?: number;
+}
+export interface VoteValue {
+    selected: string[];
+    counts: Record<string, number>;
+    total?: number;
+}
+export interface FieldServices {
+    searchOptions?: (field: FieldConfig, query: string, signal: AbortSignal) => Promise<FieldOption[]>;
+    upload?: (field: FieldConfig, files: File[], signal: AbortSignal) => Promise<AttachmentValue[]>;
+    vote?: (field: FieldConfig, selected: string[], signal: AbortSignal) => Promise<VoteValue>;
+}
+export type FieldKind = (string & {}) | "richText" | "number" | "dateTime" | "detail" | "title" | "text" | "longText" | "multiSelect" | "select" | "status" | "person" | "date" | "vote" | "relation";
+export interface FieldConfig {
+    key: string;
+    label: string;
+    kind?: FieldKind;
+    /** Registered control ID; defaults to the field kind. */
+    control?: string;
+    editable?: boolean;
+    required?: boolean;
+    options?: string[];
+    choices?: FieldOption[];
+    placeholder?: string;
+    maxLength?: number;
+    numberOptions?: {
+        min?: number;
+        max?: number;
+        step?: number;
+        decimals?: number;
+        suffix?: string;
+        thousandsSeparator?: boolean;
+    };
+    attachmentOptions?: {
+        accept?: string;
+        maxFiles?: number;
+        maxBytes?: number;
+    };
+    compositeFields?: FieldConfig[];
+    maxRows?: number;
+    /** Maximum selected values for multiSelect; omitted means unlimited. */
+    maxSelections?: number;
+    /** Calendar features. date hides time by default; dateTime shows it. */
+    dateOptions?: {
+        showTime?: boolean;
+        showRange?: boolean;
+        showSeconds?: boolean;
+    };
+    colors?: Record<string, string>;
+    defaultValue?: unknown;
+}
+export interface ControlContext extends InteractionOptions {
+    field: FieldConfig;
+    /** Opaque caller context; never interpreted by the field runtime. */
+    context?: unknown;
+    value: unknown;
+    layout?: 'compact' | 'form';
+    className?: string;
+    readonly: boolean;
+    /** Permission gate for the expanded and editing states. */
+    canEdit?: boolean;
+    onAction?: (action: {
+        type: string;
+        value?: unknown;
+    }) => void;
+    services?: FieldServices;
+    /** Host retains labels for remote selections; values still contain stable IDs only. */
+    onSelectedOptions?: (options: FieldOption[]) => void;
+    /** Optional host boundary, e.g. a popup containing its Save/Cancel buttons. */
+    focusBoundary?: HTMLElement;
+}
+export interface ControlEditor extends Partial<InteractionSource> {
+    element: HTMLElement;
+    /** Interactive surface hosted outside element, e.g. a top-layer popup.
+     *  Hosts looking for the editor's inputs must search here too. */
+    content?: HTMLElement;
+    /** A primitive may bridge portal changes to this single semantic input root. */
+    inputRoot?: HTMLElement;
+    read: () => unknown;
+    validate?: () => string | undefined;
+    focus?: () => void;
+    destroy?: () => void;
+    /** Close internal menus/fullscreen without discarding the draft. */
+    deactivate?: () => void;
+}
+export interface FieldControl {
+    id: string;
+    label: string;
+    description: string;
+    glyph: string;
+    action?: 'edit' | 'select' | 'view';
+    group?: '文本' | '选择' | '人员' | '日期' | '投票' | '其他' | '关联工作项' | '系统';
+    readonly?: boolean;
+    render: (context: ControlContext) => HTMLElement;
+    renderView?: (context: ControlContext) => FieldView;
+    createEditor: (context: ControlContext) => ControlEditor;
+}
+export type FieldState = 'display' | 'hover' | 'editing';
+/** Explicit content structure; strings are text, never implicit HTML. */
+export type FieldContent = {
+    kind: 'text';
+    text: string;
+    className?: string;
+} | {
+    kind: 'node';
+    node: HTMLElement;
+    destroy?: () => void;
+} | {
+    kind: 'group';
+    children: FieldContent[];
+    className?: string;
+};
+export interface FieldView {
+    element: HTMLElement;
+    /** Portal content also belongs to this field's input and focus boundary. */
+    content?: HTMLElement;
+    /** A primitive may bridge portal changes to this single semantic input root. */
+    inputRoot?: HTMLElement;
+    read?: () => unknown;
+    validate?: () => string | undefined;
+    focus?: () => void;
+    deactivate?: () => void;
+    destroy?: () => void;
+}
+export interface FieldSnapshot {
+    key: string;
+    value: unknown;
+    committedValue: unknown;
+    state: FieldState;
+    readonly: boolean;
+}
+export interface FieldEvent extends FieldSnapshot {
+    type: 'input' | 'change' | 'commit' | 'cancel' | 'state' | 'invalid' | 'action' | 'destroy';
+    previousValue?: unknown;
+    previousState?: FieldState;
+    message?: string;
+    action?: {
+        type: string;
+        value?: unknown;
+    };
+    source: 'api' | 'user';
+    originalEvent?: Event;
+}
+export type FieldListener = (event: FieldEvent) => void;
+export interface FieldRenderContext extends FieldSnapshot {
+    element: HTMLElement;
+    field: Readonly<FieldConfig>;
+    content: FieldContent;
+    input(value: unknown): void;
+    commit(): boolean;
+    cancel(): void;
+    edit(): void;
+    action(type: string, value?: unknown): void;
+    /** Render the subclass's default view, optionally wrapping it in a portal. */
+    renderDefault(): FieldView;
+}
+export type FieldRenderer = (context: FieldRenderContext) => FieldView;
+export interface FieldOptions extends ControlContext {
+    state?: FieldState;
+    /** Host-provided display model, recalculated for the current value. */
+    content?: FieldContent | ((snapshot: FieldSnapshot) => FieldContent);
+    renderers?: Partial<Record<FieldState, FieldRenderer>>;
+    hooks?: {
+        beforeInput?: (value: unknown, snapshot: FieldSnapshot) => unknown;
+        beforeCommit?: (event: FieldEvent) => boolean | void;
+        beforeCancel?: (event: FieldEvent) => boolean | void;
+        beforeStateChange?: (event: FieldEvent) => boolean | void;
+        validate?: (value: unknown) => string | undefined;
+    };
+    onEvent?: FieldListener;
+}

package/dist/types/fields/value-control.d.ts

@@ -0,0 +1,12 @@
+import type { ControlContext, ControlEditor } from './types';
+export declare const text: (v: unknown) => string;
+export declare const emit: (root: HTMLElement) => boolean;
+export declare function safeLink(value: unknown): string | undefined;
+export declare function plain(c: ControlContext): HTMLDivElement;
+export declare function textEditor(c: ControlContext, type: 'textarea' | 'url' | 'email' | 'tel'): ControlEditor;
+export declare function renderLink(c: ControlContext): HTMLDivElement;
+export declare function switchEditor(c: ControlContext): ControlEditor;
+export declare function renderSwitch(c: ControlContext): HTMLElement;
+export declare function renderSignal(c: ControlContext): HTMLDivElement;
+export declare function computedView(c: ControlContext): HTMLDivElement;
+export declare function readonlyEditor(c: ControlContext, render: (c: ControlContext) => HTMLElement): ControlEditor;

package/dist/types/fields/vote-control.d.ts

@@ -0,0 +1,2 @@
+import type { ControlContext, ControlEditor } from './types';
+export declare function voteEditor(c: ControlContext, mode: 'attitude' | 'single' | 'multi'): ControlEditor;

package/dist/types/forms/form-conditions.d.ts

@@ -0,0 +1,29 @@
+export type FormConditionOp = 'equals' | 'notEqual' | 'contains' | 'notContains' | 'in' | 'notIn' | 'blank' | 'notBlank';
+export interface FormConditionLeaf {
+    field: string;
+    op: FormConditionOp;
+    value?: unknown;
+}
+export type FormCondition = FormConditionLeaf | {
+    all: FormCondition[];
+} | {
+    any: FormCondition[];
+} | {
+    not: FormCondition;
+};
+/** Visibility scope: named members, teams or instance roles (Feishu 可见成员范围). */
+export interface FormScope {
+    all?: boolean;
+    members?: string[];
+    teams?: string[];
+    roles?: string[];
+}
+export interface FormSurfaceContext {
+    currentUser?: string;
+    teams?: string[];
+    /** Roles the current member holds on the instance. */
+    roles?: string[];
+    item?: unknown;
+}
+export declare function evalFormCondition(condition: FormCondition | undefined, data: Record<string, unknown>, context?: FormSurfaceContext): boolean;
+export declare function evalFormScope(scope: FormScope | undefined, context?: FormSurfaceContext): boolean;

package/dist/types/forms/form-surface.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Work-item form surface: one component that loads either the create page or
+ * the detail page from parameters.
+ *
+ * Both Feishu surfaces share one form model (fields, layout placements, tabs,
+ * conditions, permissions, defaults) and one set of three-state field controls;
+ * only the carrier (modal vs drawer), the action bar and the tab chrome differ.
+ * See docs/form-surface.md for the parameter model and the tab configuration.
+ */
+import type { FormSurfaceConfig, FormSurfaceDeps, FormSurfaceInstance } from '../contracts/work-item';
+export type { FormActionConfig, FormBlockConfig, FormFieldDef, FormFieldPermission, FormGroupConfig, FormLayoutItem, FormPlacement, FormRenderContext, FormSurfaceConfig, FormSurfaceDeps, FormSurfaceEvents, FormSurfaceInstance, FormTabConfig, FormTabKind } from '../contracts/work-item';
+export * from './form-conditions';
+export declare function createWorkItemFormSurface(config: FormSurfaceConfig, deps?: FormSurfaceDeps): FormSurfaceInstance;