@wakastellar/ui 3.5.2 → 4.0.0

package/dist/src/components/editor/blocks/index.d.ts

@@ -1,51 +0,0 @@
-/**
- * WakaStart Editor Blocks — Custom Plate.js block elements for the WakaStart ecosystem.
- *
- * These blocks extend the standard Plate editor with domain-specific elements
- * designed for PaaS project management, specification writing, and technical documentation.
- *
- * Usage:
- * ```ts
- * import { WakaUserStoryBlock, createUserStoryPlugin } from "@wakastellar/ui/editor"
- * ```
- *
- * Each block provides:
- * - A React component for rendering in the Plate editor
- * - A node factory function for creating Slate nodes
- * - A plugin factory for registering with the Plate editor
- * - Full TypeScript types for the Slate element shape
- */
-export { WakaUserStoryBlock, createUserStoryNodes, createUserStoryPlugin, USER_STORY_BLOCK_TYPE, type UserStoryElement, type WakaUserStoryBlockProps, } from './waka-user-story-block';
-export { WakaAcceptanceCriteriaBlock, createAcceptanceCriteriaNodes, createAcceptanceCriteriaPlugin, ACCEPTANCE_CRITERIA_BLOCK_TYPE, type AcceptanceCriterion, type AcceptanceCriteriaElement, type WakaAcceptanceCriteriaBlockProps, } from './waka-acceptance-criteria-block';
-export { WakaApiEndpointBlock, createApiEndpointNodes, createApiEndpointPlugin, API_ENDPOINT_BLOCK_TYPE, type HttpMethod, type ApiParam, type ApiResponse, type ApiEndpointElement, type WakaApiEndpointBlockProps, } from './waka-api-endpoint-block';
-export { WakaDiagramBlock, createDiagramNodes, createDiagramPlugin, DIAGRAM_BLOCK_TYPE, type DiagramSyntax, type DiagramElement, type WakaDiagramBlockProps, } from './waka-diagram-block';
-export { WakaAiAssistBlock, createAiAssistNodes, createAiAssistPlugin, AI_ASSIST_BLOCK_TYPE, type AiAssistStatus, type AiAssistElement, type WakaAiAssistBlockProps, } from './waka-ai-assist-block';
-export { WakaVersionDiffBlock, createVersionDiffNodes, createVersionDiffPlugin, VERSION_DIFF_BLOCK_TYPE, type DiffLine, type DiffHunk, type VersionDiffElement, type WakaVersionDiffBlockProps, } from './waka-version-diff-block';
-export { WakaEmbedBlock, createEmbedNodes, createEmbedPlugin, detectEmbedProvider, resolveEmbedUrl, EMBED_BLOCK_TYPE, type EmbedProvider, type EmbedElement, type WakaEmbedBlockProps, } from './waka-embed-block';
-export { WakaCodePlaygroundBlock, createCodePlaygroundNodes, createCodePlaygroundPlugin, CODE_PLAYGROUND_BLOCK_TYPE, type PlaygroundLanguage, type ExecutionStatus, type CodePlaygroundElement, type WakaCodePlaygroundBlockProps, } from './waka-code-playground-block';
-export { WakaCommentThreadBlock, createCommentThreadNodes, createCommentThreadPlugin, COMMENT_THREAD_BLOCK_TYPE, type ThreadComment, type ThreadStatus, type CommentThreadElement, type WakaCommentThreadBlockProps, } from './waka-comment-thread-block';
-export { WakaSlashMenuBlock, getAllWakaSlashCommands, createWakaSlashPlugins, WAKA_BLOCK_COMMANDS, type WakaSlashBlockCommand, type WakaSlashMenuBlockProps, } from './waka-slash-menu-block';
-/**
- * Loads all WakaStart block plugins at once.
- * Returns an array of Plate plugins to spread into your editor configuration.
- *
- * @example
- * ```ts
- * const blockPlugins = await loadAllWakaBlockPlugins()
- * const editor = usePlateEditor({
- *   plugins: [...corePlugins, ...blockPlugins],
- * })
- * ```
- */
-export declare function loadAllWakaBlockPlugins(options?: {
-    /** Mermaid/diagram render function */
-    diagramRenderer?: (source: string, syntax: string) => Promise<string>;
-    /** AI generation function */
-    aiGenerator?: (prompt: string) => Promise<string>;
-    /** Code execution function */
-    codeExecutor?: (code: string, language: string) => Promise<string>;
-    /** Current user ID for comments */
-    currentUserId?: string;
-    /** Comment reply handler */
-    onCommentReply?: (threadId: string, content: string) => void;
-}): Promise<unknown[]>;

package/dist/src/components/editor/blocks/waka-acceptance-criteria-block.d.ts

@@ -1,60 +0,0 @@
-import { PlateElementProps } from '../waka-editor-elements';
-export declare const ACCEPTANCE_CRITERIA_BLOCK_TYPE: "acceptance_criteria";
-/** A single acceptance criterion in Gherkin format */
-export interface AcceptanceCriterion {
-    /** Unique ID (e.g. "AC-01") */
-    id: string;
-    /** Scenario name */
-    scenario: string;
-    /** Given (context / precondition) */
-    given: string;
-    /** When (action / trigger) */
-    when: string;
-    /** Then (expected result) */
-    then: string;
-    /** Whether this criterion has been validated */
-    validated: boolean;
-}
-/** Slate node for acceptance criteria block */
-export interface AcceptanceCriteriaElement {
-    type: typeof ACCEPTANCE_CRITERIA_BLOCK_TYPE;
-    /** Block title */
-    title: string;
-    /** List of criteria */
-    criteria: AcceptanceCriterion[];
-    children: Array<{
-        text: string;
-    }>;
-}
-export interface WakaAcceptanceCriteriaBlockProps extends PlateElementProps {
-    element?: AcceptanceCriteriaElement & Record<string, unknown>;
-    /** Whether the block is read-only */
-    readOnly?: boolean;
-}
-/**
- * WakaAcceptanceCriteriaBlock - A Plate.js block for acceptance criteria in
- * Gherkin format (Given/When/Then). Each criterion has a checkbox for
- * validation tracking.
- *
- * Register in Plate editor:
- * ```ts
- * components: {
- *   [ACCEPTANCE_CRITERIA_BLOCK_TYPE]: WakaAcceptanceCriteriaBlock,
- * }
- * ```
- */
-export declare function WakaAcceptanceCriteriaBlock({ attributes, children, element, className, }: WakaAcceptanceCriteriaBlockProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace WakaAcceptanceCriteriaBlock {
-    var displayName: string;
-}
-/**
- * Creates Slate nodes for an acceptance criteria block.
- */
-export declare function createAcceptanceCriteriaNodes(options?: {
-    title?: string;
-    criteria?: AcceptanceCriterion[];
-}): AcceptanceCriteriaElement[];
-/**
- * Creates a Plate plugin for acceptance criteria blocks.
- */
-export declare function createAcceptanceCriteriaPlugin(): Promise<any>;

package/dist/src/components/editor/blocks/waka-ai-assist-block.d.ts

@@ -1,58 +0,0 @@
-import { PlateElementProps } from '../waka-editor-elements';
-export declare const AI_ASSIST_BLOCK_TYPE: "ai_assist";
-/** Status of the AI request */
-export type AiAssistStatus = "idle" | "loading" | "streaming" | "complete" | "error";
-/** Slate node for AI assist blocks */
-export interface AiAssistElement {
-    type: typeof AI_ASSIST_BLOCK_TYPE;
-    /** The user's prompt/question */
-    prompt: string;
-    /** The AI-generated response */
-    response: string;
-    /** Current status */
-    status: AiAssistStatus;
-    /** Model used for generation */
-    model?: string;
-    /** Timestamp of generation */
-    generatedAt?: string;
-    /** Error message if status is "error" */
-    errorMessage?: string;
-    /** Token count */
-    tokenCount?: number;
-    children: Array<{
-        text: string;
-    }>;
-}
-export interface WakaAiAssistBlockProps extends PlateElementProps {
-    element?: AiAssistElement & Record<string, unknown>;
-    /** Callback to trigger AI generation. Receives the prompt, returns a response or streams it. */
-    onGenerate?: (prompt: string) => Promise<string>;
-    /** Callback when the user accepts the response and wants it inserted into the document */
-    onAccept?: (response: string) => void;
-    /** Callback when the user discards the response */
-    onDiscard?: () => void;
-}
-/**
- * WakaAiAssistBlock - A Plate.js block where the user poses a question or prompt,
- * and the AI response is inserted directly into the document. Supports streaming
- * responses, accept/discard actions, and model attribution.
- *
- * Designed to work with `@platejs/ai` AIChatPlugin, or standalone with a custom
- * `onGenerate` callback.
- *
- * Register in Plate editor:
- * ```ts
- * components: {
- *   [AI_ASSIST_BLOCK_TYPE]: (props) => <WakaAiAssistBlock {...props} onGenerate={myHandler} />,
- * }
- * ```
- */
-export declare function WakaAiAssistBlock({ attributes, children, element, className, onGenerate, onAccept, onDiscard, }: WakaAiAssistBlockProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace WakaAiAssistBlock {
-    var displayName: string;
-}
-export declare function createAiAssistNodes(options?: {
-    prompt?: string;
-    model?: string;
-}): AiAssistElement[];
-export declare function createAiAssistPlugin(onGenerate?: (prompt: string) => Promise<string>, onAccept?: (response: string) => void): Promise<any>;

package/dist/src/components/editor/blocks/waka-api-endpoint-block.d.ts

@@ -1,63 +0,0 @@
-import { PlateElementProps } from '../waka-editor-elements';
-export declare const API_ENDPOINT_BLOCK_TYPE: "api_endpoint";
-/** HTTP method type */
-export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
-/** A single parameter/header definition */
-export interface ApiParam {
-    name: string;
-    type: string;
-    required: boolean;
-    description: string;
-}
-/** A response definition */
-export interface ApiResponse {
-    status: number;
-    description: string;
-    body?: string;
-}
-/** Slate node for API endpoint block */
-export interface ApiEndpointElement {
-    type: typeof API_ENDPOINT_BLOCK_TYPE;
-    /** HTTP method */
-    method: HttpMethod;
-    /** Route path (e.g. "/api/v1/projects/:id") */
-    route: string;
-    /** Endpoint description */
-    description: string;
-    /** Authentication requirement */
-    auth: string;
-    /** Required permissions/roles */
-    permissions: string[];
-    /** Rate limit description */
-    rateLimit?: string;
-    /** Path/query parameters */
-    params?: ApiParam[];
-    /** Request body (JSON string) */
-    requestBody?: string;
-    /** Response definitions */
-    responses: ApiResponse[];
-    children: Array<{
-        text: string;
-    }>;
-}
-export interface WakaApiEndpointBlockProps extends PlateElementProps {
-    element?: ApiEndpointElement & Record<string, unknown>;
-}
-/**
- * WakaApiEndpointBlock - A Plate.js block for documenting REST API endpoints.
- * Displays method, route, parameters, request body, and responses with
- * syntax-colored JSON previews.
- *
- * Register in Plate editor:
- * ```ts
- * components: {
- *   [API_ENDPOINT_BLOCK_TYPE]: WakaApiEndpointBlock,
- * }
- * ```
- */
-export declare function WakaApiEndpointBlock({ attributes, children, element, className, }: WakaApiEndpointBlockProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace WakaApiEndpointBlock {
-    var displayName: string;
-}
-export declare function createApiEndpointNodes(options?: Partial<Omit<ApiEndpointElement, "type" | "children">>): ApiEndpointElement[];
-export declare function createApiEndpointPlugin(): Promise<any>;

package/dist/src/components/editor/blocks/waka-code-playground-block.d.ts

@@ -1,61 +0,0 @@
-import { PlateElementProps } from '../waka-editor-elements';
-export declare const CODE_PLAYGROUND_BLOCK_TYPE: "code_playground";
-/** Supported programming languages */
-export type PlaygroundLanguage = "javascript" | "typescript" | "python" | "html" | "css" | "json" | "sql" | "bash" | "go" | "rust";
-/** Execution status */
-export type ExecutionStatus = "idle" | "running" | "success" | "error";
-/** Slate node for code playground blocks */
-export interface CodePlaygroundElement {
-    type: typeof CODE_PLAYGROUND_BLOCK_TYPE;
-    /** Source code */
-    code: string;
-    /** Programming language */
-    language: PlaygroundLanguage;
-    /** Title / filename */
-    title?: string;
-    /** Last execution output */
-    output?: string;
-    /** Last execution error */
-    errorOutput?: string;
-    /** Execution status */
-    executionStatus: ExecutionStatus;
-    /** Whether to show line numbers */
-    showLineNumbers: boolean;
-    /** Whether the code is read-only */
-    readOnly: boolean;
-    children: Array<{
-        text: string;
-    }>;
-}
-export interface WakaCodePlaygroundBlockProps extends PlateElementProps {
-    element?: CodePlaygroundElement & Record<string, unknown>;
-    /** Callback to execute code. Returns stdout output or throws with stderr. */
-    onExecute?: (code: string, language: PlaygroundLanguage) => Promise<string>;
-}
-/**
- * WakaCodePlaygroundBlock - A Plate.js block with an inline code editor and
- * sandboxed execution. Users write code and can run it, seeing output in
- * an integrated console panel.
- *
- * Execution is sandboxed via the `onExecute` callback provided by the
- * consuming application (e.g. using Web Workers, iframes, or server-side eval).
- *
- * Register in Plate editor:
- * ```ts
- * components: {
- *   [CODE_PLAYGROUND_BLOCK_TYPE]: (props) => (
- *     <WakaCodePlaygroundBlock {...props} onExecute={myExecutor} />
- *   ),
- * }
- * ```
- */
-export declare function WakaCodePlaygroundBlock({ attributes, children, element, className, onExecute, }: WakaCodePlaygroundBlockProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace WakaCodePlaygroundBlock {
-    var displayName: string;
-}
-export declare function createCodePlaygroundNodes(options?: {
-    code?: string;
-    language?: PlaygroundLanguage;
-    title?: string;
-}): CodePlaygroundElement[];
-export declare function createCodePlaygroundPlugin(onExecute?: (code: string, language: PlaygroundLanguage) => Promise<string>): Promise<any>;

package/dist/src/components/editor/blocks/waka-comment-thread-block.d.ts

@@ -1,85 +0,0 @@
-import { PlateElementProps } from '../waka-editor-elements';
-export declare const COMMENT_THREAD_BLOCK_TYPE: "comment_thread";
-/** A single comment in a thread */
-export interface ThreadComment {
-    /** Unique comment ID */
-    id: string;
-    /** Author information */
-    author: {
-        id: string;
-        name: string;
-        avatar?: string;
-    };
-    /** Comment text content */
-    content: string;
-    /** ISO timestamp */
-    createdAt: string;
-    /** Whether this comment has been edited */
-    edited?: boolean;
-    /** Reactions on this comment */
-    reactions?: Array<{
-        emoji: string;
-        count: number;
-        reacted: boolean;
-    }>;
-}
-/** Thread status */
-export type ThreadStatus = "open" | "resolved" | "archived";
-/** Slate node for comment thread blocks */
-export interface CommentThreadElement {
-    type: typeof COMMENT_THREAD_BLOCK_TYPE;
-    /** Thread ID */
-    threadId: string;
-    /** The original highlighted text that was commented on */
-    quotedText: string;
-    /** Thread status */
-    status: ThreadStatus;
-    /** Comments in the thread */
-    comments: ThreadComment[];
-    /** Total number of comments (may differ from comments.length if paginated) */
-    totalComments?: number;
-    children: Array<{
-        text: string;
-    }>;
-}
-export interface WakaCommentThreadBlockProps extends PlateElementProps {
-    element?: CommentThreadElement & Record<string, unknown>;
-    /** Current user ID (for highlighting own comments) */
-    currentUserId?: string;
-    /** Callback when a reply is submitted */
-    onReply?: (threadId: string, content: string) => void;
-    /** Callback when thread is resolved */
-    onResolve?: (threadId: string) => void;
-    /** Callback when thread is reopened */
-    onReopen?: (threadId: string) => void;
-}
-/**
- * WakaCommentThreadBlock - A Plate.js block for inline threaded comments,
- * similar to Google Docs commenting. Shows the quoted text that was commented on,
- * a thread of replies, and allows adding new replies.
- *
- * Designed to integrate with `@platejs/comments` or work standalone.
- *
- * Register in Plate editor:
- * ```ts
- * components: {
- *   [COMMENT_THREAD_BLOCK_TYPE]: (props) => (
- *     <WakaCommentThreadBlock {...props} currentUserId="user-123" onReply={handleReply} />
- *   ),
- * }
- * ```
- */
-export declare function WakaCommentThreadBlock({ attributes, children, element, className, currentUserId, onReply, onResolve, onReopen, }: WakaCommentThreadBlockProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace WakaCommentThreadBlock {
-    var displayName: string;
-}
-export declare function createCommentThreadNodes(options?: {
-    threadId?: string;
-    quotedText?: string;
-    initialComment?: {
-        authorId: string;
-        authorName: string;
-        content: string;
-    };
-}): CommentThreadElement[];
-export declare function createCommentThreadPlugin(currentUserId?: string, onReply?: (threadId: string, content: string) => void, onResolve?: (threadId: string) => void): Promise<any>;

package/dist/src/components/editor/blocks/waka-diagram-block.d.ts

@@ -1,52 +0,0 @@
-import { PlateElementProps } from '../waka-editor-elements';
-export declare const DIAGRAM_BLOCK_TYPE: "diagram";
-/** Supported diagram syntax types */
-export type DiagramSyntax = "mermaid" | "plantuml" | "excalidraw";
-/** Slate node for diagram blocks */
-export interface DiagramElement {
-    type: typeof DIAGRAM_BLOCK_TYPE;
-    /** Diagram syntax type */
-    syntax: DiagramSyntax;
-    /** Raw source code of the diagram */
-    source: string;
-    /** Optional title/caption */
-    caption?: string;
-    children: Array<{
-        text: string;
-    }>;
-}
-export interface WakaDiagramBlockProps extends PlateElementProps {
-    element?: DiagramElement & Record<string, unknown>;
-    /**
-     * External render function: takes diagram source and syntax,
-     * returns sanitized SVG string or HTML.
-     *
-     * IMPORTANT: The consuming application is responsible for sanitizing
-     * the returned HTML (e.g. using DOMPurify) before it is rendered.
-     */
-    onRender?: (source: string, syntax: DiagramSyntax) => Promise<string>;
-}
-/**
- * WakaDiagramBlock - A Plate.js block that embeds a diagram editor (Mermaid/PlantUML/Excalidraw)
- * inline in the document. The user writes diagram source code and sees the rendered
- * output below.
- *
- * The rendering is delegated to an external `onRender` callback, allowing the consuming
- * app to use mermaid.js, kroki.io, or any other renderer. The consuming app MUST sanitize
- * the rendered output (e.g. using DOMPurify) before returning it.
- *
- * If no `onRender` is provided, only the source code is displayed.
- *
- * Register in Plate editor:
- * ```ts
- * components: {
- *   [DIAGRAM_BLOCK_TYPE]: (props) => <WakaDiagramBlock {...props} onRender={myRenderer} />,
- * }
- * ```
- */
-export declare function WakaDiagramBlock({ attributes, children, element, className, onRender, }: WakaDiagramBlockProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace WakaDiagramBlock {
-    var displayName: string;
-}
-export declare function createDiagramNodes(options?: Partial<Omit<DiagramElement, "type" | "children">>): DiagramElement[];
-export declare function createDiagramPlugin(onRender?: (source: string, syntax: DiagramSyntax) => Promise<string>): Promise<any>;

package/dist/src/components/editor/blocks/waka-embed-block.d.ts

@@ -1,58 +0,0 @@
-import { PlateElementProps } from '../waka-editor-elements';
-export declare const EMBED_BLOCK_TYPE: "embed";
-/** Supported embed provider types */
-export type EmbedProvider = "figma" | "youtube" | "vimeo" | "codesandbox" | "codepen" | "stackblitz" | "loom" | "miro" | "notion" | "github-gist" | "generic";
-/** Slate node for embed blocks */
-export interface EmbedElement {
-    type: typeof EMBED_BLOCK_TYPE;
-    /** Original URL pasted by the user */
-    url: string;
-    /** Detected embed provider */
-    provider: EmbedProvider;
-    /** Resolved embed/iframe URL */
-    embedUrl: string;
-    /** Title/caption */
-    title?: string;
-    /** Aspect ratio (e.g. "16/9", "4/3", "1/1") */
-    aspectRatio?: string;
-    /** Optional maximum height in pixels */
-    maxHeight?: number;
-    children: Array<{
-        text: string;
-    }>;
-}
-export interface WakaEmbedBlockProps extends PlateElementProps {
-    element?: EmbedElement & Record<string, unknown>;
-}
-/**
- * Detect provider from a URL.
- */
-export declare function detectEmbedProvider(url: string): EmbedProvider;
-/**
- * Transform a URL into an embeddable iframe URL.
- */
-export declare function resolveEmbedUrl(url: string, provider: EmbedProvider): string;
-/**
- * WakaEmbedBlock - A Plate.js block for embedding external content (Figma, YouTube,
- * CodeSandbox, Loom, etc.) inline in a document. The user pastes a URL and the
- * block auto-detects the provider and renders the appropriate embed.
- *
- * Uses `@platejs/media` patterns. All URLs are sanitized before embedding.
- *
- * Register in Plate editor:
- * ```ts
- * components: {
- *   [EMBED_BLOCK_TYPE]: WakaEmbedBlock,
- * }
- * ```
- */
-export declare function WakaEmbedBlock({ attributes, children, element, className, }: WakaEmbedBlockProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace WakaEmbedBlock {
-    var displayName: string;
-}
-export declare function createEmbedNodes(url: string, options?: {
-    title?: string;
-    aspectRatio?: string;
-    maxHeight?: number;
-}): EmbedElement[];
-export declare function createEmbedPlugin(): Promise<any>;

package/dist/src/components/editor/blocks/waka-slash-menu-block.d.ts

@@ -1,67 +0,0 @@
-import { SlashCommand } from '../waka-slash-menu';
-import * as React from "react";
-/** Extended slash command with WakaStart-specific blocks */
-export interface WakaSlashBlockCommand extends SlashCommand {
-    /** Preview/thumbnail for the block */
-    preview?: React.ReactNode;
-    /** Whether this is a WakaStart custom block (vs standard Plate block) */
-    isCustom?: boolean;
-}
-export interface WakaSlashMenuBlockProps {
-    /** All available commands (merges with defaults) */
-    commands?: WakaSlashBlockCommand[];
-    /** Filter query (typed after "/") */
-    query?: string;
-    /** Called when a command is selected */
-    onSelect?: (command: WakaSlashBlockCommand) => void;
-    /** Active (highlighted) index */
-    activeIndex?: number;
-    /** Callback when active index changes */
-    onActiveIndexChange?: (index: number) => void;
-    /** CSS class */
-    className?: string;
-}
-/**
- * WakaStart-specific slash commands for custom blocks.
- * These extend the standard Plate slash commands with blocks specific
- * to the WakaStart specification and project management workflow.
- */
-export declare const WAKA_BLOCK_COMMANDS: WakaSlashBlockCommand[];
-/**
- * Get all slash commands: standard Plate commands + WakaStart custom blocks.
- */
-export declare function getAllWakaSlashCommands(extraCommands?: WakaSlashBlockCommand[]): WakaSlashBlockCommand[];
-/**
- * WakaSlashMenuBlock - An enhanced slash menu that includes all standard Plate
- * blocks PLUS WakaStart-specific custom blocks (User Story, API Endpoint,
- * Diagram, AI Assist, Code Playground, etc.).
- *
- * This replaces the standard WakaSlashMenu when you want the full WakaStart
- * block vocabulary available in your editor.
- *
- * @example
- * ```tsx
- * // In your Plate slash plugin configuration:
- * const slashPlugins = await createWakaSlashPlugins()
- *
- * // Or use the menu component standalone:
- * <WakaSlashMenuBlock
- *   query={searchQuery}
- *   onSelect={(cmd) => cmd.action(editor)}
- * />
- * ```
- */
-export declare function WakaSlashMenuBlock({ commands, query, onSelect, activeIndex: controlledIndex, onActiveIndexChange, className, }: WakaSlashMenuBlockProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace WakaSlashMenuBlock {
-    var displayName: string;
-}
-/**
- * Creates slash command plugin configuration with all WakaStart blocks registered.
- *
- * @example
- * ```ts
- * const plugins = await createWakaSlashPlugins()
- * // Add to editor plugins array
- * ```
- */
-export declare function createWakaSlashPlugins(extraCommands?: WakaSlashBlockCommand[]): Promise<any[]>;

package/dist/src/components/editor/blocks/waka-user-story-block.d.ts

@@ -1,79 +0,0 @@
-import { PlateElementProps } from '../waka-editor-elements';
-/** Slate node type for user story blocks */
-export declare const USER_STORY_BLOCK_TYPE: "user_story";
-/** Shape of a user story element in the Slate document */
-export interface UserStoryElement {
-    type: typeof USER_STORY_BLOCK_TYPE;
-    /** The role ("As a ...") */
-    role: string;
-    /** The action ("I want ...") */
-    action: string;
-    /** The benefit ("So that ...") */
-    benefit: string;
-    /** Optional story ID (e.g. "US-042") */
-    storyId?: string;
-    /** Optional priority */
-    priority?: "must" | "should" | "could" | "wont";
-    /** Optional story points estimate */
-    points?: number;
-    children: Array<{
-        text: string;
-    }>;
-}
-/** Props for the WakaUserStoryBlock element renderer */
-export interface WakaUserStoryBlockProps extends PlateElementProps {
-    element?: UserStoryElement & Record<string, unknown>;
-    /** Called when a field value changes */
-    onFieldChange?: (field: "role" | "action" | "benefit", value: string) => void;
-}
-/**
- * WakaUserStoryBlock - A Plate.js block element for writing User Stories
- * in the structured format "As a [role], I want [action], so that [benefit]".
- *
- * Each field is editable inline within the block. Renders with a distinctive
- * visual treatment: blue left border, user icon, and structured layout.
- *
- * Register as a custom element in your Plate editor:
- * ```ts
- * const editor = usePlateEditor({
- *   plugins: [...],
- *   components: {
- *     [USER_STORY_BLOCK_TYPE]: WakaUserStoryBlock,
- *   },
- * })
- * ```
- *
- * Insert via slash command or programmatically:
- * ```ts
- * editor.insertNodes(createUserStoryNodes())
- * ```
- */
-export declare function WakaUserStoryBlock({ attributes, children, element, className, }: WakaUserStoryBlockProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace WakaUserStoryBlock {
-    var displayName: string;
-}
-/**
- * Creates the Slate nodes for inserting a user story block.
- *
- * @param options - Optional pre-fill values
- * @returns Array of Slate nodes to insert
- */
-export declare function createUserStoryNodes(options?: {
-    role?: string;
-    action?: string;
-    benefit?: string;
-    storyId?: string;
-    priority?: "must" | "should" | "could" | "wont";
-    points?: number;
-}): UserStoryElement[];
-/**
- * Creates a Plate plugin configuration for user story blocks.
- * Use with dynamic import for tree-shaking.
- *
- * @example
- * ```ts
- * const userStoryPlugin = await createUserStoryPlugin()
- * // Add to editor plugins
- * ```
- */
-export declare function createUserStoryPlugin(): Promise<any>;