@use-kona/editor 0.1.21 → 0.1.22

package/dist/plugins/CommandsPlugin/resolveCommands.spec.js

@@ -1,323 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { CommandsResolver } from "./resolveCommands.js";
-const editor = {};
-const leaf = (params)=>({
-        name: params.name,
-        title: params.title,
-        commandName: params.commandName ?? params.title.toLocaleLowerCase(),
-        icon: null,
-        action: ()=>{}
-    });
-const deferred = ()=>{
-    let resolve = ()=>{};
-    let reject = ()=>{};
-    const promise = new Promise((res, rej)=>{
-        resolve = res;
-        reject = rej;
-    });
-    return {
-        promise,
-        resolve,
-        reject
-    };
-};
-describe('CommandsResolver', ()=>{
-    it('keeps leaf-only legacy behavior', async ()=>{
-        const resolver = new CommandsResolver();
-        const rootCommands = [
-            leaf({
-                name: 'paragraph',
-                title: 'Paragraph'
-            }),
-            leaf({
-                name: 'code',
-                title: 'Code'
-            })
-        ];
-        const request = resolver.resolve({
-            rootCommands,
-            filter: '',
-            path: [],
-            editor
-        });
-        const result = await request.promise;
-        expect(result.commands.map((item)=>item.command.name)).toEqual([
-            'paragraph',
-            'code'
-        ]);
-    });
-    it('resolves static submenu with sync getCommands', async ()=>{
-        const resolver = new CommandsResolver();
-        const rootCommands = [
-            {
-                name: 'insert',
-                title: 'Insert',
-                commandName: 'insert',
-                icon: null,
-                getCommands: ()=>[
-                        leaf({
-                            name: 'heading-1',
-                            title: 'Heading 1'
-                        })
-                    ]
-            }
-        ];
-        const request = resolver.resolve({
-            rootCommands,
-            filter: '',
-            path: [
-                {
-                    name: 'insert',
-                    title: 'Insert',
-                    commandName: 'insert'
-                }
-            ],
-            editor
-        });
-        const result = await request.promise;
-        expect(result.commands).toHaveLength(1);
-        expect(result.commands[0]?.command.name).toBe('heading-1');
-    });
-    it('resolves async submenu', async ()=>{
-        const resolver = new CommandsResolver();
-        const rootCommands = [
-            {
-                name: 'remote',
-                title: 'Remote',
-                commandName: 'remote',
-                icon: null,
-                getCommands: async ()=>[
-                        leaf({
-                            name: 'code',
-                            title: 'Code'
-                        })
-                    ]
-            }
-        ];
-        const request = resolver.resolve({
-            rootCommands,
-            filter: '',
-            path: [
-                {
-                    name: 'remote',
-                    title: 'Remote',
-                    commandName: 'remote'
-                }
-            ],
-            editor
-        });
-        const result = await request.promise;
-        expect(result.commands).toHaveLength(1);
-        expect(result.commands[0]?.command.name).toBe('code');
-    });
-    it('searches only root level when path is empty', async ()=>{
-        const resolver = new CommandsResolver();
-        const rootCommands = [
-            {
-                name: 'insert',
-                title: 'Insert',
-                commandName: 'insert',
-                icon: null,
-                getCommands: ()=>[
-                        leaf({
-                            name: 'code',
-                            title: 'Code'
-                        })
-                    ]
-            },
-            leaf({
-                name: 'paragraph',
-                title: 'Paragraph'
-            })
-        ];
-        const request = resolver.resolve({
-            rootCommands,
-            filter: 'code',
-            path: [],
-            editor
-        });
-        const result = await request.promise;
-        expect(result.commands).toHaveLength(0);
-    });
-    it('searches only current nested level', async ()=>{
-        const resolver = new CommandsResolver();
-        const rootCommands = [
-            {
-                name: 'insert',
-                title: 'Insert',
-                commandName: 'insert',
-                icon: null,
-                getCommands: ()=>[
-                        leaf({
-                            name: 'code',
-                            title: 'Code'
-                        })
-                    ]
-            }
-        ];
-        const request = resolver.resolve({
-            rootCommands,
-            filter: 'code',
-            path: [
-                {
-                    name: 'insert',
-                    title: 'Insert',
-                    commandName: 'insert'
-                }
-            ],
-            editor
-        });
-        const result = await request.promise;
-        expect(result.commands).toHaveLength(1);
-        expect(result.commands[0]?.command.name).toBe('code');
-    });
-    it('returns matching submenu commands in query mode', async ()=>{
-        const resolver = new CommandsResolver();
-        const rootCommands = [
-            {
-                name: 'advanced',
-                title: 'Advanced',
-                commandName: 'advanced',
-                icon: null,
-                getCommands: ()=>[
-                        leaf({
-                            name: 'code',
-                            title: 'Code'
-                        })
-                    ]
-            }
-        ];
-        const request = resolver.resolve({
-            rootCommands,
-            filter: 'adv',
-            path: [],
-            editor
-        });
-        const result = await request.promise;
-        expect(result.commands).toHaveLength(1);
-        expect(result.commands[0]?.command.name).toBe('advanced');
-        expect(result.commands[0]?.isSubmenu).toBe(true);
-    });
-    it('ignores stale out-of-order async responses', async ()=>{
-        const resolver = new CommandsResolver();
-        const searchA = deferred();
-        const searchB = deferred();
-        const rootCommands = [
-            {
-                name: 'remote',
-                title: 'Remote',
-                commandName: 'remote',
-                icon: null,
-                getCommands: ({ query })=>{
-                    if ('a' === query) return searchA.promise;
-                    return searchB.promise;
-                }
-            }
-        ];
-        const firstRequest = resolver.resolve({
-            rootCommands,
-            filter: 'a',
-            path: [
-                {
-                    name: 'remote',
-                    title: 'Remote',
-                    commandName: 'remote'
-                }
-            ],
-            editor
-        });
-        const secondRequest = resolver.resolve({
-            rootCommands,
-            filter: 'b',
-            path: [
-                {
-                    name: 'remote',
-                    title: 'Remote',
-                    commandName: 'remote'
-                }
-            ],
-            editor
-        });
-        searchB.resolve([
-            leaf({
-                name: 'b',
-                title: 'Result B',
-                commandName: 'b'
-            })
-        ]);
-        const secondResult = await secondRequest.promise;
-        expect(secondResult.commands.map((item)=>item.command.name)).toEqual([
-            'b'
-        ]);
-        searchA.resolve([
-            leaf({
-                name: 'a',
-                title: 'Result A',
-                commandName: 'a'
-            })
-        ]);
-        const firstResult = await firstRequest.promise;
-        expect(firstResult.commands.map((item)=>item.command.name)).toEqual([
-            'b'
-        ]);
-        expect(resolver.getState().commands.map((item)=>item.command.name)).toEqual([
-            'b'
-        ]);
-    });
-    it('clears visible commands while loading new results', async ()=>{
-        const resolver = new CommandsResolver();
-        const remoteDeferred = deferred();
-        const rootCommands = [
-            leaf({
-                name: 'paragraph',
-                title: 'Paragraph'
-            }),
-            {
-                name: 'remote',
-                title: 'Remote',
-                commandName: 'remote',
-                icon: null,
-                getCommands: ({ query })=>{
-                    if (query) return remoteDeferred.promise;
-                    return [
-                        leaf({
-                            name: 'code',
-                            title: 'Code'
-                        })
-                    ];
-                }
-            }
-        ];
-        const initial = await resolver.resolve({
-            rootCommands,
-            filter: '',
-            path: [],
-            editor
-        }).promise;
-        const loadingRequest = resolver.resolve({
-            rootCommands,
-            filter: 'code',
-            path: [
-                {
-                    name: 'remote',
-                    title: 'Remote',
-                    commandName: 'remote'
-                }
-            ],
-            editor
-        });
-        expect(loadingRequest.state.isLoading).toBe(true);
-        expect(initial.commands.length).toBeGreaterThan(0);
-        expect(loadingRequest.state.commands).toEqual([]);
-        remoteDeferred.resolve([
-            leaf({
-                name: 'code',
-                title: 'Code'
-            })
-        ]);
-        const settled = await loadingRequest.promise;
-        expect(settled.isLoading).toBe(false);
-        expect(settled.commands).toHaveLength(1);
-        expect(settled.commands[0]?.command.name).toBe('code');
-    });
-});

package/dist/plugins/ListsPlugin/ListsPlugin.spec.d.ts

@@ -1,3 +0,0 @@
-/** @jsxRuntime classic */
-/** @jsx jsx */
-export {};

package/dist/plugins/ListsPlugin/ListsPlugin.spec.js

@@ -1,47 +0,0 @@
-import { createHyperscript, createText } from "slate-hyperscript";
-import { describe, expect, it } from "vitest";
-import { createEditor } from "../../core/createEditor.js";
-import { ListsPlugin } from "./ListsPlugin.js";
-const ListsPlugin_spec_elements = {
-    paragraph: {
-        type: 'paragraph'
-    },
-    numberedList: {
-        type: ListsPlugin.NUMBERED_LIST_ELEMENT
-    },
-    bulletedList: {
-        type: ListsPlugin.BULLETED_LIST_ELEMENT
-    },
-    listItem: {
-        type: ListsPlugin.LIST_ITEM_ELEMENT
-    }
-};
-const jsx = createHyperscript({
-    elements: ListsPlugin_spec_elements,
-    creators: {
-        text: createText
-    }
-});
-const createEditorWithPlugin = (children)=>{
-    const editorState = /*#__PURE__*/ jsx("editor", null, children);
-    const editor = createEditor([
-        new ListsPlugin()
-    ])();
-    editor.children = editorState.children;
-    editor.selection = editorState.selection;
-    return editor;
-};
-describe('ListsPlugin', ()=>{
-    it('should change current block to bulleted list', ()=>{
-        const editor = createEditorWithPlugin(/*#__PURE__*/ jsx("paragraph", null, /*#__PURE__*/ jsx("cursor", null), /*#__PURE__*/ jsx("text", null, "Hello world")));
-        ListsPlugin.toggleList(editor, ListsPlugin.BULLETED_LIST_ELEMENT);
-        const output = /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("bulletedList", null, /*#__PURE__*/ jsx("listItem", null, /*#__PURE__*/ jsx("text", null, "Hello world"))), /*#__PURE__*/ jsx("paragraph", null, /*#__PURE__*/ jsx("text", null)));
-        expect(editor.children).toEqual(output.children);
-    });
-    it('should change current block to numbered list', ()=>{
-        const editor = createEditorWithPlugin(/*#__PURE__*/ jsx("paragraph", null, /*#__PURE__*/ jsx("cursor", null), /*#__PURE__*/ jsx("text", null, "Hello world")));
-        ListsPlugin.toggleList(editor, ListsPlugin.NUMBERED_LIST_ELEMENT);
-        const output = /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("numberedList", null, /*#__PURE__*/ jsx("listItem", null, /*#__PURE__*/ jsx("text", null, "Hello world"))), /*#__PURE__*/ jsx("paragraph", null, /*#__PURE__*/ jsx("text", null)));
-        expect(editor.children).toEqual(output.children);
-    });
-});

package/dist/plugins/MenuPlugin/MenuPlugin.d.ts

@@ -1,7 +0,0 @@
-import type { IPlugin, UiParams } from '../../types';
-import type { Options } from './types';
-export declare class MenuPlugin implements IPlugin {
-    private options;
-    constructor(options: Options);
-    ui: (params: UiParams) => string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
-}