@freecallai/pro 0.0.0-stage → 0.0.1

package/dist/types/rich-text/runtime/operations.d.ts

@@ -0,0 +1,48 @@
+import { JSONContent } from '@tiptap/core';
+import { CapabilityDescriptor } from '../config/catalog';
+import { PluginOperation } from '../plugins/operations';
+export type NodeMutationPlan = {
+    ok: true;
+    kind: 'updateNode';
+    nodeId: string;
+    expectedNodeVersion: number;
+    node: JSONContent;
+} | {
+    ok: true;
+    kind: 'removeNode';
+    nodeId: string;
+    expectedNodeVersion: number;
+};
+export type DocumentPlan = {
+    ok: true;
+    kind: 'doc';
+    content: JSONContent[];
+} | {
+    ok: true;
+    kind: 'replaceDoc';
+    doc: JSONContent;
+    question?: string;
+    confirmation: string;
+} | NodeMutationPlan | {
+    ok: true;
+    kind: 'batchNodes';
+    operations: readonly NodeMutationPlan[];
+};
+export type PluginPlan = {
+    ok: false;
+    reason: string;
+} | {
+    ok: true;
+    kind: 'none';
+} | {
+    ok: true;
+    kind: 'state';
+    data: Record<string, unknown>;
+} | DocumentPlan | {
+    ok: true;
+    kind: 'compound';
+    data: Record<string, unknown>;
+    document: DocumentPlan;
+};
+/** Validate the whole plugin result before any scene or editor mutation. */
+export declare function planPluginOperations(descriptor: CapabilityDescriptor, operations: readonly PluginOperation[]): PluginPlan;

package/dist/types/rich-text/runtime/option-menu-session.d.ts

@@ -0,0 +1,28 @@
+import { ResolvedCapability } from '../config/resolve';
+import { CapabilityId, CapabilityOption, PortRequestContext, PortResult, RichTextHostPorts } from '../public/types';
+type PortError = Extract<PortResult<unknown>, {
+    ok: false;
+}>['error'];
+export interface OptionMenuSessionHost {
+    descriptor(id: CapabilityId): ResolvedCapability | undefined;
+    ports(): RichTextHostPorts | undefined;
+    context(id: CapabilityId, controller: AbortController): PortRequestContext;
+    isCurrent(id: CapabilityId): boolean;
+    track(controller: AbortController, start: boolean): void;
+    diagnostic(code: string, message: string, id: CapabilityId): void;
+    portDiagnostic(error: PortError, id: CapabilityId): void;
+}
+/** Owns option search, hierarchy, pagination, and cancellation as one menu session. */
+export declare function createOptionMenuSession(host: OptionMenuSessionHost): {
+    query: import('vue').Ref<string, string>;
+    options: import('vue').ShallowRef<CapabilityOption[], CapabilityOption[]>;
+    path: import('vue').ShallowRef<CapabilityOption[], CapabilityOption[]>;
+    nextCursor: import('vue').Ref<string | null, string | null>;
+    loading: import('vue').Ref<boolean, boolean>;
+    abort: () => void;
+    reset: () => void;
+    enter: (option: CapabilityOption) => void;
+    back: () => boolean;
+    fetch: (id: CapabilityId, append?: boolean) => Promise<void>;
+};
+export {};

package/dist/types/rich-text/runtime/option-source.d.ts

@@ -0,0 +1,10 @@
+import { CapabilityDescriptor } from '../config/descriptor';
+import { CapabilityOption, Page, PortRequestContext, PortResult, RichTextHostPorts } from '../public/types';
+export interface OptionQuery {
+    search?: string;
+    cursor?: string;
+    parentId?: string;
+    limit: number;
+}
+/** Shared menu transport. Capability descriptors choose the source; host DTOs stay validated here. */
+export declare function requestCapabilityOptions(descriptor: CapabilityDescriptor, query: OptionQuery, ports: RichTextHostPorts | undefined, request: PortRequestContext): Promise<PortResult<Page<CapabilityOption>> | null>;

package/dist/types/rich-text/runtime/port-result.d.ts

@@ -0,0 +1,21 @@
+import { JSONContent } from '@tiptap/core';
+import { AgentPrompt, AgentSummary, CapabilityOption, EditorDiagnostic, MediaAsset, Page, PortResult, ToolFormDefinition, VariableOption } from '../public/types';
+export declare function isDiagnostic(value: unknown): value is EditorDiagnostic;
+export declare function parsePortResult<T>(raw: unknown, validData: (data: unknown) => data is T): PortResult<T>;
+export declare const isVariablePage: (data: unknown) => data is Page<VariableOption>;
+export declare const isAgentPage: (data: unknown) => data is Page<AgentSummary>;
+export declare const isCapabilityPage: (data: unknown) => data is Page<CapabilityOption>;
+export declare const isFlatTagPage: (data: unknown) => data is Page<CapabilityOption>;
+export declare const isToolFormDefinition: (toolId: string, data: unknown) => data is ToolFormDefinition;
+export interface ReasoningProposal {
+    proposedDoc: JSONContent;
+    explanation?: string;
+}
+export declare const isReasoningProposal: (data: unknown) => data is ReasoningProposal;
+export interface ReasoningTemplate {
+    question: string;
+    doc: JSONContent;
+}
+export declare const isReasoningTemplate: (data: unknown) => data is ReasoningTemplate;
+export declare const isAgentPrompt: (id: string, data: unknown) => data is AgentPrompt;
+export declare const isMediaAsset: (kind: "image" | "video", data: unknown) => data is MediaAsset;

package/dist/types/rich-text/runtime/schema-plan.d.ts

@@ -0,0 +1,17 @@
+import { JSONContent } from '@tiptap/core';
+import { CapabilityId, CapabilitySlot } from '../public/types';
+type CapabilityAccess = {
+    id: CapabilityId;
+    slot: CapabilitySlot;
+    canInsert: boolean;
+};
+export interface KnowledgeSchemaPlan {
+    businessToken: boolean;
+    originalReply: boolean;
+    separator: boolean;
+    mediaBlock: boolean;
+}
+/** Keep stored nodes readable when their insert action has been revoked. */
+export declare function planKnowledgeSchema(capabilities: readonly CapabilityAccess[], doc: JSONContent | null): KnowledgeSchemaPlan;
+export declare function schemaPlanKey(plan: KnowledgeSchemaPlan): string;
+export {};

package/dist/types/rich-text/runtime/tool-form-session.d.ts

@@ -0,0 +1,39 @@
+import { MediaTarget } from './media-target';
+import { KnowledgeType, PortRequestContext, PortResult, RichTextHostPorts, ToolFormDefinition } from '../public/types';
+export interface ToolEditRequest {
+    key: string;
+    label: string;
+    params: Record<string, unknown>;
+    target?: MediaTarget;
+    nodeId?: string;
+    nodeVersion?: number;
+    sceneKey: string;
+    type: KnowledgeType;
+}
+type ToolFormPort = NonNullable<RichTextHostPorts['getToolForm']>;
+type PortError = Extract<PortResult<unknown>, {
+    ok: false;
+}>['error'];
+export interface ToolFormSessionHost {
+    getPort(): ToolFormPort | undefined;
+    getScene(): {
+        sceneKey: string;
+        type: KnowledgeType;
+    };
+    canUse(): boolean;
+    context(controller: AbortController): PortRequestContext;
+    track(controller: AbortController, start: boolean): void;
+    diagnostic(code: string, message: string, source: 'config' | 'port' | 'validation'): void;
+    portDiagnostic(error: PortError): void;
+}
+/** Owns one tool-form request and its target bookmark from open through commit. */
+export declare function createToolFormSession(host: ToolFormSessionHost): {
+    edit: import('vue').ShallowRef<ToolEditRequest | null, ToolEditRequest | null>;
+    definition: import('vue').ShallowRef<ToolFormDefinition | null, ToolFormDefinition | null>;
+    cancel: () => void;
+    portChanged: (current: ToolFormPort | undefined, previous: ToolFormPort | undefined) => void;
+    open: (request: ToolEditRequest) => Promise<void>;
+    recheck: (request: ToolEditRequest, initial: ToolFormDefinition) => Promise<boolean>;
+    releaseForInsert: () => void;
+};
+export {};

package/dist/types/rich-text/runtime/tool-params.d.ts

@@ -0,0 +1,5 @@
+import { ToolFormDefinition, ToolFormField } from '../public/types';
+/** Keep conditional fields and their editor controls on the same initial value. */
+export declare function initialToolFieldValue(field: ToolFormField, params: Record<string, unknown>): string | boolean;
+/** Editing must not silently coerce or drop parameters from an older form. */
+export declare function findUnrepresentableToolParam(params: Record<string, unknown>, definition: ToolFormDefinition): string | null;

package/dist/types/rich-text/types.d.ts

@@ -0,0 +1,40 @@
+import { JSONContent } from '@tiptap/core';
+export type KnowledgeMode = 'normal' | 'reasoning';
+export interface KnowledgeSettings {
+    mode: KnowledgeMode;
+    memory: boolean;
+    tagged: boolean;
+    todo: boolean;
+    original: boolean;
+}
+export interface VariableOption {
+    key: string;
+    label: string;
+    group?: string;
+}
+export interface MediaUploadResult {
+    url: string;
+    id?: string;
+    poster?: string;
+}
+export type MediaUploader = (file: File, context: {
+    signal: AbortSignal;
+}) => Promise<MediaUploadResult>;
+export interface EditorChange {
+    json: JSONContent;
+    html: string;
+    text: string;
+}
+export interface FkpRichTextProps {
+    modelValue?: JSONContent;
+    question?: string;
+    settings?: KnowledgeSettings;
+    variables?: VariableOption[];
+    readonly?: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    maxHeight?: number;
+    maxFileSize?: number;
+    upload?: MediaUploader;
+}
+export declare const defaultSettings: () => KnowledgeSettings;

package/dist/types/rich-text/ui/CapabilityHelp.vue.d.ts

@@ -0,0 +1,9 @@
+type __VLS_Props = {
+    capabilityId: 'originalReply' | 'memory' | 'separator';
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    help: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onHelp?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/types/rich-text/ui/KnowledgeArea.vue.d.ts

@@ -0,0 +1,117 @@
+import { JSONContent } from '@tiptap/core';
+import { KnowledgeSchemaPlan } from '../runtime/schema-plan';
+import { ChoiceTokenKind } from '../model/node-contract';
+import { MediaNodeState } from '../runtime/media-state';
+import { NodeMutationPlan, PluginPlan } from '../runtime/operations';
+import { MediaTarget } from '../runtime/media-target';
+type __VLS_Props = {
+    modelValue: JSONContent;
+    editable: boolean;
+    placeholder?: string;
+    referencePlaceholder?: boolean;
+    schemaPlan: KnowledgeSchemaPlan;
+    activeChoiceId?: string | null;
+};
+declare function insertToken(kind: string, key: string, label: string, token?: string): void;
+declare function insertOriginal(): void;
+declare function insertSeparator(): void;
+declare function insertBatch(content: JSONContent[], target: MediaTarget, refocus: boolean): JSONContent | null;
+declare function restoreDoc(doc: JSONContent): void;
+declare function insertMedia(asset: {
+    id?: string;
+    url: string;
+    kind: 'image' | 'video';
+    posterUrl?: string;
+}, name: string, target?: MediaTarget): boolean;
+declare function insertPendingMedia(file: File, kind: 'image' | 'video', target: MediaTarget): string | null;
+declare function getMediaState(id: string): MediaNodeState | null;
+declare function applyNodeUpdate(plan: Extract<PluginPlan, {
+    kind: 'updateNode';
+}>, owner: 'image' | 'video'): boolean;
+declare function previewPluginNodeOperations(plans: readonly NodeMutationPlan[], owner: string): JSONContent | null;
+declare function applyPluginNodeOperations(plans: readonly NodeMutationPlan[], owner: string): boolean;
+declare function applyPluginNodeOperation(plan: NodeMutationPlan, owner: string): boolean;
+declare function failMedia(id: string, message: string, expectedNodeVersion: number): boolean;
+declare function retryMedia(id: string, expectedNodeVersion: number): boolean;
+declare function reportMediaProgress(id: string, expectedNodeVersion: number, percent: number): boolean;
+declare function captureSelection(): {
+    nodeCaret?: {
+        id: string;
+        kind: "inlineAfter";
+        offset: number;
+    } | {
+        id: string;
+        kind: "blockAfter";
+        offset: number;
+        siblingOffset: number;
+    } | undefined;
+    from: number;
+    to: number;
+    focused: boolean;
+} | null;
+declare function restoreSelection(selection: ReturnType<typeof captureSelection>): void;
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    isSelectionInsideOriginalReply: () => boolean;
+    insertToken: typeof insertToken;
+    insertOriginal: typeof insertOriginal;
+    insertSeparator: typeof insertSeparator;
+    insertBatch: typeof insertBatch;
+    restoreDoc: typeof restoreDoc;
+    insertMedia: typeof insertMedia;
+    insertPendingMedia: typeof insertPendingMedia;
+    applyNodeUpdate: typeof applyNodeUpdate;
+    applyPluginNodeOperation: typeof applyPluginNodeOperation;
+    applyPluginNodeOperations: typeof applyPluginNodeOperations;
+    previewPluginNodeOperations: typeof previewPluginNodeOperations;
+    failMedia: typeof failMedia;
+    retryMedia: typeof retryMedia;
+    getMediaState: typeof getMediaState;
+    reportMediaProgress: typeof reportMediaProgress;
+    captureSelection: typeof captureSelection;
+    restoreSelection: typeof restoreSelection;
+    captureMediaTarget: () => MediaTarget | null;
+    captureMediaTargetAt: (clientX: number, clientY: number) => MediaTarget | null;
+    focus: () => boolean | undefined;
+    getJSON: () => import('@tiptap/core').DocumentType<Record<string, any> | undefined, import('@tiptap/core').NodeType<string, Record<string, any> | undefined, any, (import('@tiptap/core').NodeType<any, any, any, any> | import('@tiptap/core').TextType<import('@tiptap/core').MarkType<any, any>>)[]>[]> | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: JSONContent) => any;
+    "retry-media": (id: string) => any;
+    "load-error": (message: string) => any;
+    "edit-tool": (payload: {
+        nodeId: string;
+        nodeVersion: number;
+        key: string;
+        label: string;
+        params: Record<string, unknown> | null;
+    }) => any;
+    "choice-menu": (payload: {
+        nodeId: string;
+        nodeVersion: number;
+        key: string;
+        kind: ChoiceTokenKind;
+        anchor: HTMLElement;
+    }) => any;
+    "leave-choice": () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: JSONContent) => any) | undefined;
+    "onRetry-media"?: ((id: string) => any) | undefined;
+    "onLoad-error"?: ((message: string) => any) | undefined;
+    "onEdit-tool"?: ((payload: {
+        nodeId: string;
+        nodeVersion: number;
+        key: string;
+        label: string;
+        params: Record<string, unknown> | null;
+    }) => any) | undefined;
+    "onChoice-menu"?: ((payload: {
+        nodeId: string;
+        nodeVersion: number;
+        key: string;
+        kind: ChoiceTokenKind;
+        anchor: HTMLElement;
+    }) => any) | undefined;
+    "onLeave-choice"?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    areaRoot: HTMLDivElement;
+}, any>;
+export default _default;

package/dist/types/rich-text/ui/ToolForm.vue.d.ts

@@ -0,0 +1,14 @@
+import { ToolFormDefinition } from '../public/types';
+type __VLS_Props = {
+    definition: ToolFormDefinition;
+    initialParams: Record<string, unknown>;
+    submitLabel: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: () => any;
+    submit: (params: Record<string, string | boolean>, focusTrigger: EventTarget | null) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onSubmit?: ((params: Record<string, string | boolean>, focusTrigger: EventTarget | null) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/types/rich-text/ui/VariableOptionList.vue.d.ts

@@ -0,0 +1,15 @@
+import { CapabilityOption } from '../public/types';
+type __VLS_Props = {
+    options: CapabilityOption[];
+    loading: boolean;
+    nextCursor: string | null;
+    query: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    choose: (option: CapabilityOption, event: Event) => any;
+    loadMore: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChoose?: ((option: CapabilityOption, event: Event) => any) | undefined;
+    onLoadMore?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/package.json

@@ -1,6 +1,73 @@
 {
   "name": "@freecallai/pro",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.1",
+  "description": "福客AI业务组件库",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@gitee.com/chengduzhihuige/fuker-ui.git",
+    "directory": "packages/web-vue-pro"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./rich-text": {
+      "types": "./dist/types/rich-text/index.d.ts",
+      "import": "./dist/rich-text/index.js"
+    },
+    "./rich-text/legacy-converter": {
+      "types": "./dist/types/rich-text/legacy-converter/index.d.ts",
+      "import": "./dist/rich-text/legacy-converter/index.js"
+    },
+    "./style.css": "./dist/style.css"
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "peerDependencies": {
+    "@freecallai/ui": "^0.0.1",
+    "vue": "^3.5.13"
+  },
+  "dependencies": {
+    "@tiptap/core": "^3.0.0",
+    "@tiptap/extension-placeholder": "^3.0.0",
+    "@tiptap/pm": "^3.0.0",
+    "@tiptap/starter-kit": "^3.0.0",
+    "@tiptap/vue-3": "^3.0.0",
+    "@freecallai/icons": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@vitejs/plugin-vue": "^5.2.0",
+    "jsdom": "^26.0.0",
+    "typescript": "~5.7.3",
+    "vite": "^6.4.0",
+    "vite-plugin-dts": "^4.5.0",
+    "vitest": "^3.2.0",
+    "vue": "^3.5.13",
+    "vue-tsc": "^2.2.0",
+    "@arco-design/arco-vue-scripts": "0.2.10",
+    "@freecallai/ui": "0.0.1"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node scripts/check-rich-text-boundaries.mjs && vue-tsc --noEmit && vite build",
+    "check:boundaries": "node scripts/check-rich-text-boundaries.mjs",
+    "docgen": "arco-vue-scripts docgen",
+    "typecheck": "vue-tsc --noEmit",
+    "test": "vitest run"
+  }
 }