zs_library 0.6.21 → 0.7.0

package/dist/components/tiptap-editor/simple/lib/feature-utils.d.ts

@@ -0,0 +1,124 @@
+import { Level } from '../components/tiptap-ui/heading-button';
+import { ListType } from '../components/tiptap-ui/list-button';
+import { HighlightColor } from '../components/tiptap-ui/color-highlight-button';
+import { ImageUploadProps } from './image-upload-handler';
+import { AiCompletionOptions } from './ai-service';
+export interface FeatureConfig<T = unknown> {
+    enabled?: boolean;
+    configure?: T;
+}
+export interface BaseButtonConfig {
+    text?: string;
+    showShortcut?: boolean;
+    hideWhenUnavailable?: boolean;
+}
+export interface HeadingConfig extends BaseButtonConfig {
+    levels?: Level[];
+}
+export interface ListConfig extends BaseButtonConfig {
+    types?: ListType[];
+}
+export interface HighlightConfig extends BaseButtonConfig {
+    multicolor?: boolean;
+    colors?: HighlightColor[];
+}
+export interface LinkConfig extends BaseButtonConfig {
+    openOnClick?: boolean;
+    enableClickSelection?: boolean;
+    autoOpenOnLinkActive?: boolean;
+}
+export interface TextAlignConfig extends BaseButtonConfig {
+    types?: string[];
+    alignments?: string[];
+    defaultAlignment?: string;
+}
+export interface ImageConfig extends BaseButtonConfig, ImageUploadProps {
+}
+export interface AiPreset {
+    label: string;
+    text: string;
+    icon?: React.ReactNode;
+}
+export interface AiConfig extends BaseButtonConfig {
+    defaultPrompt?: string;
+    defaultModel?: string;
+    systemPrompt?: string;
+    presets?: AiPreset[];
+    /**
+     * The API Key for the AI service (e.g., DeepSeek, OpenAI).
+     */
+    apiKey?: string;
+    /**
+     * The Base URL for the AI service API.
+     * Default: "https://api.deepseek.com"
+     */
+    baseUrl?: string;
+    /**
+     * The model to use for completion.
+     * Default: "deepseek-chat"
+     */
+    model?: string;
+    /**
+     * Custom request headers
+     */
+    headers?: Record<string, string>;
+    /**
+     * Custom query parameters to append to the URL
+     */
+    params?: Record<string, string>;
+    /**
+     * Additional body parameters to merge with the request body
+     */
+    body?: Record<string, unknown>;
+    /**
+     * Custom request function to completely override the default behavior.
+     * If provided, it should handle the API call and return the generated text.
+     * For streaming, it should call `onUpdate` with the accumulating text.
+     */
+    request?: (options: AiCompletionOptions) => Promise<string>;
+    /**
+     * Custom function to transform the response.
+     * Useful if using a custom `request` or if the API returns a different format.
+     * Not used if `request` is provided and handles everything, but can be used
+     * if `request` returns a raw object that needs parsing.
+     *
+     * Actually, for the default implementation, we parse OpenAI-compatible stream.
+     * If the user wants to transform the final result or chunks, this might be tricky with streaming.
+     * Let's stick to `request` override for full control.
+     * But maybe `transformResponse` is for the final string?
+     */
+    /**
+     * Callback when the AI generation starts.
+     */
+    onStart?: () => void;
+    /**
+     * Callback when the AI generation is successful.
+     */
+    onSuccess?: (content: string) => void;
+    /**
+     * Callback when the AI generation fails.
+     */
+    onError?: (error: Error) => void;
+}
+export interface SimpleEditorFeatures {
+    undoRedo?: boolean | FeatureConfig<BaseButtonConfig>;
+    heading?: boolean | FeatureConfig<HeadingConfig>;
+    list?: boolean | FeatureConfig<ListConfig>;
+    blockquote?: boolean | FeatureConfig<BaseButtonConfig>;
+    codeBlock?: boolean | FeatureConfig<BaseButtonConfig>;
+    bold?: boolean | FeatureConfig<BaseButtonConfig>;
+    italic?: boolean | FeatureConfig<BaseButtonConfig>;
+    strike?: boolean | FeatureConfig<BaseButtonConfig>;
+    code?: boolean | FeatureConfig<BaseButtonConfig>;
+    underline?: boolean | FeatureConfig<BaseButtonConfig>;
+    highlight?: boolean | FeatureConfig<HighlightConfig>;
+    link?: boolean | FeatureConfig<LinkConfig>;
+    subscript?: boolean | FeatureConfig<BaseButtonConfig>;
+    superscript?: boolean | FeatureConfig<BaseButtonConfig>;
+    textAlign?: boolean | FeatureConfig<TextAlignConfig>;
+    image?: boolean | FeatureConfig<ImageConfig>;
+    themeToggle?: boolean;
+    ai?: boolean | FeatureConfig<AiConfig>;
+}
+export declare const isEnabled: (config: boolean | FeatureConfig | undefined, defaultValue?: boolean) => boolean;
+export declare const getConfig: <T>(config: boolean | FeatureConfig<T> | undefined) => T | undefined;

package/dist/components/tiptap-editor/simple/lib/image-upload-handler.d.ts

@@ -0,0 +1,44 @@
+export type RequestMethod = "POST" | "PUT" | "PATCH" | "post" | "put" | "patch";
+export interface UploadRequestOption {
+    action: string;
+    file: File;
+    headers?: Record<string, string>;
+    onError: (error: Error) => void;
+    onProgress: (event: {
+        percent: number;
+    }) => void;
+    onSuccess: (body: unknown) => void;
+    withCredentials?: boolean;
+}
+export interface ImageUploadProps {
+    /** Upload URL */
+    action?: string | ((file: File) => Promise<string>);
+    /** HTTP method */
+    method?: RequestMethod;
+    /** Request headers */
+    headers?: Record<string, string> | ((file: File) => Record<string, string> | Promise<Record<string, string>>);
+    /** File parameter name */
+    name?: string;
+    /** Extra parameters */
+    data?: Record<string, unknown> | ((file: File) => Record<string, unknown> | Promise<Record<string, unknown>>);
+    /** Send cookies */
+    withCredentials?: boolean;
+    /** Format response to image url */
+    formatResult?: (response: unknown) => string;
+    /** Custom request implementation */
+    customRequest?: (options: UploadRequestOption) => void;
+}
+interface UploadHandlerParams {
+    file: File;
+    onProgress?: (event: {
+        progress: number;
+    }) => void;
+    imageProps?: ImageUploadProps;
+}
+/**
+ * Handles image upload logic based on provided props.
+ * Defaults to fetch for network requests if action is provided.
+ * Falls back to mock upload if no action or customRequest is provided.
+ */
+export declare const handleImageUploadRequest: ({ file, onProgress, imageProps, }: UploadHandlerParams) => Promise<string>;
+export {};

package/dist/components/tiptap-editor/simple/lib/tiptap-utils.d.ts

@@ -0,0 +1,167 @@
+import { Node as PMNode } from '@tiptap/pm/model';
+import { Transaction, Selection } from '@tiptap/pm/state';
+import { Editor, NodeWithPos } from '@tiptap/react';
+export declare const MAX_FILE_SIZE: number;
+export declare const MAC_SYMBOLS: Record<string, string>;
+export declare const SR_ONLY: {
+    readonly position: "absolute";
+    readonly width: "1px";
+    readonly height: "1px";
+    readonly padding: 0;
+    readonly margin: "-1px";
+    readonly overflow: "hidden";
+    readonly clip: "rect(0, 0, 0, 0)";
+    readonly whiteSpace: "nowrap";
+    readonly borderWidth: 0;
+};
+export declare function cn(...classes: (string | boolean | undefined | null)[]): string;
+/**
+ * Determines if the current platform is macOS
+ * @returns boolean indicating if the current platform is Mac
+ */
+export declare function isMac(): boolean;
+/**
+ * Formats a shortcut key based on the platform (Mac or non-Mac)
+ * @param key - The key to format (e.g., "ctrl", "alt", "shift")
+ * @param isMac - Boolean indicating if the platform is Mac
+ * @param capitalize - Whether to capitalize the key (default: true)
+ * @returns Formatted shortcut key symbol
+ */
+export declare const formatShortcutKey: (key: string, isMac: boolean, capitalize?: boolean) => string;
+/**
+ * Parses a shortcut key string into an array of formatted key symbols
+ * @param shortcutKeys - The string of shortcut keys (e.g., "ctrl-alt-shift")
+ * @param delimiter - The delimiter used to split the keys (default: "-")
+ * @param capitalize - Whether to capitalize the keys (default: true)
+ * @returns Array of formatted shortcut key symbols
+ */
+export declare const parseShortcutKeys: (props: {
+    shortcutKeys: string | undefined;
+    delimiter?: string;
+    capitalize?: boolean;
+}) => string[];
+/**
+ * Checks if a mark exists in the editor schema
+ * @param markName - The name of the mark to check
+ * @param editor - The editor instance
+ * @returns boolean indicating if the mark exists in the schema
+ */
+export declare const isMarkInSchema: (markName: string, editor: Editor | null) => boolean;
+/**
+ * Checks if a node exists in the editor schema
+ * @param nodeName - The name of the node to check
+ * @param editor - The editor instance
+ * @returns boolean indicating if the node exists in the schema
+ */
+export declare const isNodeInSchema: (nodeName: string, editor: Editor | null) => boolean;
+/**
+ * Moves the focus to the next node in the editor
+ * @param editor - The editor instance
+ * @returns boolean indicating if the focus was moved
+ */
+export declare function focusNextNode(editor: Editor): boolean;
+/**
+ * Checks if a value is a valid number (not null, undefined, or NaN)
+ * @param value - The value to check
+ * @returns boolean indicating if the value is a valid number
+ */
+export declare function isValidPosition(pos: number | null | undefined): pos is number;
+/**
+ * Checks if one or more extensions are registered in the Tiptap editor.
+ * @param editor - The Tiptap editor instance
+ * @param extensionNames - A single extension name or an array of names to check
+ * @returns True if at least one of the extensions is available, false otherwise
+ */
+export declare function isExtensionAvailable(editor: Editor | null, extensionNames: string | string[]): boolean;
+/**
+ * Finds a node at the specified position with error handling
+ * @param editor The Tiptap editor instance
+ * @param position The position in the document to find the node
+ * @returns The node at the specified position, or null if not found
+ */
+export declare function findNodeAtPosition(editor: Editor, position: number): PMNode | null;
+/**
+ * Finds the position and instance of a node in the document
+ * @param props Object containing editor, node (optional), and nodePos (optional)
+ * @param props.editor The Tiptap editor instance
+ * @param props.node The node to find (optional if nodePos is provided)
+ * @param props.nodePos The position of the node to find (optional if node is provided)
+ * @returns An object with the position and node, or null if not found
+ */
+export declare function findNodePosition(props: {
+    editor: Editor | null;
+    node?: PMNode | null;
+    nodePos?: number | null;
+}): {
+    pos: number;
+    node: PMNode;
+} | null;
+/**
+ * Determines whether the current selection contains a node whose type matches
+ * any of the provided node type names.
+ * @param editor Tiptap editor instance
+ * @param nodeTypeNames List of node type names to match against
+ * @param checkAncestorNodes Whether to check ancestor node types up the depth chain
+ */
+export declare function isNodeTypeSelected(editor: Editor | null, nodeTypeNames?: string[], checkAncestorNodes?: boolean): boolean;
+/**
+ * Check whether the current selection is fully within nodes
+ * whose type names are in the provided `types` list.
+ *
+ * - NodeSelection → checks the selected node.
+ * - Text/AllSelection → ensures all textblocks within [from, to) are allowed.
+ */
+export declare function selectionWithinConvertibleTypes(editor: Editor, types?: string[]): boolean;
+/**
+ * Handles image upload with progress tracking and abort capability
+ * @param file The file to upload
+ * @param onProgress Optional callback for tracking upload progress
+ * @param abortSignal Optional AbortSignal for cancelling the upload
+ * @returns Promise resolving to the URL of the uploaded image
+ */
+export declare const handleImageUpload: (file: File, onProgress?: (event: {
+    progress: number;
+}) => void, abortSignal?: AbortSignal) => Promise<string>;
+type ProtocolOptions = {
+    /**
+     * The protocol scheme to be registered.
+     * @default '''
+     * @example 'ftp'
+     * @example 'git'
+     */
+    scheme: string;
+    /**
+     * If enabled, it allows optional slashes after the protocol.
+     * @default false
+     * @example true
+     */
+    optionalSlashes?: boolean;
+};
+type ProtocolConfig = Array<ProtocolOptions | string>;
+export declare function isAllowedUri(uri: string | undefined, protocols?: ProtocolConfig): true | RegExpMatchArray | null;
+export declare function sanitizeUrl(inputUrl: string, baseUrl: string, protocols?: ProtocolConfig): string;
+/**
+ * Update a single attribute on multiple nodes.
+ *
+ * @param tr - The transaction to mutate
+ * @param targets - Array of { node, pos }
+ * @param attrName - Attribute key to update
+ * @param next - New value OR updater function receiving previous value
+ *               Pass `undefined` to remove the attribute.
+ * @returns true if at least one node was updated, false otherwise
+ */
+export declare function updateNodesAttr<A extends string = string, V = unknown>(tr: Transaction, targets: readonly NodeWithPos[], attrName: A, next: V | ((prev: V | undefined) => V | undefined)): boolean;
+/**
+ * Selects the entire content of the current block node if the selection is empty.
+ * If the selection is not empty, it does nothing.
+ * @param editor The Tiptap editor instance
+ */
+export declare function selectCurrentBlockContent(editor: Editor): void;
+/**
+ * Retrieves all nodes of specified types from the current selection.
+ * @param selection The current editor selection
+ * @param allowedNodeTypes An array of node type names to look for (e.g., ["image", "table"])
+ * @returns An array of objects containing the node and its position
+ */
+export declare function getSelectedNodesOfType(selection: Selection, allowedNodeTypes: string[]): NodeWithPos[];
+export {};

package/dist/components/tiptap-editor/simple/simple-editor.d.ts

@@ -0,0 +1,10 @@
+import { JSONContent } from '@tiptap/react';
+import { SimpleEditorFeatures } from './lib/feature-utils';
+export interface SimpleEditorProps {
+    value?: string | JSONContent;
+    onChange?: (value: string) => void;
+    className?: string;
+    style?: React.CSSProperties;
+    features?: SimpleEditorFeatures;
+}
+export declare function SimpleEditor({ value, onChange, className, style, features }: SimpleEditorProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/tiptap-editor/simple/theme-toggle.d.ts

@@ -0,0 +1 @@
+export declare function ThemeToggle(): import("react/jsx-runtime").JSX.Element;