@net-vim/core 0.2.1 → 0.3.1

package/dist/src/VimEditor.d.ts

@@ -0,0 +1,5 @@
+import { VimEngine } from './vim-engine';
+export default function VimEditor(props: {
+    engine?: VimEngine;
+    ref?: (engine: VimEngine) => void;
+}): import("solid-js").JSX.Element;

package/dist/src/VimUI.d.ts

@@ -0,0 +1,55 @@
+import { Component } from 'solid-js';
+import { VimMode, GutterOptions, LineRendererOptions } from './types';
+interface VimUIProps {
+    buffer: string[] | (() => string[]);
+    cursor: {
+        x: number;
+        y: number;
+    } | (() => {
+        x: number;
+        y: number;
+    });
+    visualStart?: {
+        x: number;
+        y: number;
+    } | null | (() => {
+        x: number;
+        y: number;
+    } | null);
+    topLine?: number | (() => number);
+    leftCol?: number | (() => number);
+    mode: VimMode | (() => VimMode);
+    commandText: string | (() => string);
+    commandCursorX?: number | (() => number);
+    width: number | (() => number);
+    height: number | (() => number);
+    currentFilePath?: string | null | (() => string | null);
+    isExplorer?: boolean | (() => boolean);
+    explorerPath?: string | (() => string);
+    isReadOnly?: boolean | (() => boolean);
+    plugins?: Array<{
+        name: string;
+    }> | (() => Array<{
+        name: string;
+    }>);
+    gutters?: GutterOptions[] | (() => GutterOptions[]);
+    lineRenderers?: LineRendererOptions[] | (() => LineRendererOptions[]);
+    completionItems?: any[] | (() => any[]);
+    selectedCompletionIndex?: number | (() => number);
+    hoverText?: string | null | (() => string | null);
+    hoverPos?: {
+        x: number;
+        y: number;
+    } | (() => {
+        x: number;
+        y: number;
+    });
+    statusMessage?: string | null | (() => string | null);
+    wrap: boolean | (() => boolean);
+    onCursorChange?: (cursor: {
+        x: number;
+        y: number;
+    }) => void;
+}
+export declare const VimUI: Component<VimUIProps>;
+export {};

package/dist/src/WebGLRenderer.d.ts

@@ -0,0 +1,19 @@
+interface WebGLRendererProps {
+    chars: Uint8Array;
+    fgs: Uint8Array;
+    bgs: Uint8Array;
+    width: number;
+    height: number;
+    cursorX: number;
+    cursorY: number;
+    crtEnabled?: boolean;
+    showKeyboard?: boolean;
+    onMeasure?: (size: {
+        width: number;
+        height: number;
+    }) => void;
+}
+export declare const WebGLRenderer: (props: WebGLRendererProps & {
+    canvasRef?: (el: HTMLCanvasElement) => void;
+}) => import("solid-js").JSX.Element;
+export {};

package/dist/src/index.d.ts

@@ -0,0 +1,12 @@
+import { VimEngine } from './vim-engine';
+export { default as VimEditor } from './VimEditor';
+export * from './types';
+export * from './vim-engine';
+export * from './plugin-manager';
+export interface InitOptions {
+    wasmUrl?: string;
+}
+export declare function initNetVim(container: HTMLElement, options?: InitOptions): Promise<{
+    vim: VimEngine;
+    dispose: () => void;
+}>;

package/dist/src/line-numbers-plugin.d.ts

@@ -0,0 +1,11 @@
+import { ScopedVimAPI } from './plugin-manager';
+declare const _default: {
+    metadata: {
+        name: string;
+        author: string;
+        version: string;
+        description: string;
+    };
+    setup: (api: ScopedVimAPI) => void;
+};
+export default _default;

package/dist/src/opfs-util.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Simple utility to interact with the Origin Private File System (OPFS)
+ */
+export declare const PRELUDE_BASE = ".config/net-vim/prelude";
+export declare const opfsFS: {
+    readFile: typeof getConfigFile;
+    writeFile: typeof writeConfigFile;
+    listDirectory: typeof listDirectory;
+    isDirectory: typeof isDirectory;
+};
+export declare function getConfigFile(path: string): Promise<string | null>;
+export declare function ensureConfigDir(path: string): Promise<FileSystemDirectoryHandle>;
+export declare function writeConfigFile(path: string, content: string): Promise<void>;
+export declare function listDirectory(path: string): Promise<string[]>;
+export declare function isDirectory(path: string): Promise<boolean>;

package/dist/src/plugin-manager.d.ts

@@ -0,0 +1,42 @@
+import { VimAPI } from './types';
+import { h } from './solid-universal-tui';
+export interface ScopedVimAPI extends VimAPI {
+    storage: {
+        get: (key: string) => any;
+        set: (key: string, value: any) => void;
+    };
+    log: (...args: any[]) => void;
+    fs: {
+        readFile: (path: string) => Promise<string | null>;
+        writeFile: (path: string, content: string) => Promise<void>;
+    };
+    configFs: {
+        readFile: (path: string) => Promise<string | null>;
+        writeFile: (path: string, content: string) => Promise<void>;
+    };
+    h: typeof h;
+    babel: any;
+}
+export interface PluginMetadata {
+    name: string;
+    author?: string;
+    version?: string;
+    description?: string;
+}
+export interface WebVimPlugin {
+    metadata: PluginMetadata;
+    setup: (api: ScopedVimAPI) => void | Promise<void>;
+}
+export declare class PluginManager {
+    private plugins;
+    private pluginStates;
+    private getBaseAPI;
+    constructor(getBaseAPI: () => VimAPI);
+    /**
+     * Loads a TypeScript plugin from a raw string
+     */
+    loadPluginFromSource(name: string, tsSource: string): Promise<boolean>;
+    private registerPlugin;
+    private createScopedAPI;
+    getLoadedPlugins(): PluginMetadata[];
+}

package/dist/src/plugin-manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/prelude/context-menu.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    metadata: {
+        name: string;
+        description: string;
+    };
+    setup: (api: any) => void;
+};
+export default _default;

package/dist/src/prelude/eruda.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    metadata: {
+        name: string;
+        description: string;
+    };
+    setup: (api: any) => void;
+};
+export default _default;

package/dist/src/prelude/external-fs.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    metadata: {
+        name: string;
+        description: string;
+    };
+    setup: (api: any) => void;
+};
+export default _default;

package/dist/src/prelude/hello.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    metadata: {
+        name: string;
+        description: string;
+    };
+    setup: (api: any) => void;
+};
+export default _default;

package/dist/src/prelude/line-numbers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    metadata: {
+        name: string;
+        author: string;
+        version: string;
+        description: string;
+    };
+    setup: (api: any) => void;
+};
+export default _default;

package/dist/src/prelude/ts-lsp-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/prelude/ts-lsp.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    metadata: {
+        name: string;
+        description: string;
+    };
+    setup: (api: any) => Promise<void>;
+};
+export default _default;

package/dist/src/prelude.d.ts

@@ -0,0 +1 @@
+export declare const PRELUDE_PLUGINS: Record<string, string>;

package/dist/src/solid-universal-tui/index.d.ts

@@ -0,0 +1,24 @@
+import { JSX as SolidJSX } from 'solid-js';
+export interface TuiElement {
+    type: 'Box' | 'Text';
+    props: any;
+    children: TuiElement[];
+}
+export declare const Fragment: (props: any) => any;
+export declare const render: (code: () => any, node: any) => () => void, effect: <T>(fn: (prev?: T) => T, init?: T) => void, memo: <T>(fn: () => T, equal: boolean) => () => T, createComponent: <T>(Comp: (props: T) => any, props: T) => any, createElement: (tag: string) => any, createTextNode: (value: string) => any, insertNode: (parent: any, node: any, anchor?: any) => void, insert: <T>(parent: any, accessor: T | (() => T), marker?: any | null, initial?: any) => any, spread: <T>(node: any, accessor: (() => T) | T, skipChildren?: boolean) => void, setProp: <T>(node: any, name: string, value: T, prev?: T | undefined) => T, mergeProps: (...sources: unknown[]) => unknown;
+export declare function h(tag: any, props: any, ...children: any[]): any;
+export declare namespace JSX {
+    type Element = SolidJSX.Element;
+    type ArrayElement = SolidJSX.ArrayElement;
+    type FunctionElement = SolidJSX.FunctionElement;
+    interface IntrinsicElements {
+        'tui-box': any;
+        'tui-text': any;
+        box: any;
+        text: any;
+    }
+    type ElementClass = SolidJSX.ElementClass;
+    type ElementAttributesProperty = SolidJSX.ElementAttributesProperty;
+    type ElementChildrenAttribute = SolidJSX.ElementChildrenAttribute;
+    type IntrinsicAttributes = SolidJSX.IntrinsicAttributes;
+}

package/dist/src/solid-universal-tui/jsx-dev-runtime.d.ts

@@ -0,0 +1 @@
+export * from './index.ts';

package/dist/src/solid-universal-tui/jsx-runtime.d.ts

@@ -0,0 +1 @@
+export * from './index.ts';

package/dist/src/types.d.ts

@@ -0,0 +1,137 @@
+declare module "solid-js" {
+    namespace JSX {
+        interface IntrinsicElements {
+            'tui-box': any;
+            'tui-text': any;
+            'text': any;
+            'box': any;
+        }
+    }
+}
+export declare const TYPES_VERSION = "1.0.0";
+export type VimMode = 'Normal' | 'Insert' | 'Command' | 'Visual';
+export type VimEvent = 'ModeChanged' | 'CursorMoved' | 'TextChanged' | 'BufferLoaded' | 'FileChanged' | 'FileDeleted' | 'KeyDown' | 'FSChanged';
+export interface CompletionItem {
+    label: string;
+    kind?: string;
+    detail?: string;
+    documentation?: string;
+}
+export interface ContextMenuItem {
+    label: string;
+    action: () => void;
+    priority?: number;
+}
+export interface GutterOptions {
+    name: string;
+    width: number;
+    priority?: number;
+    /**
+     * A function that returns a TUI element for a given line.
+     * Plugins can use the provided 'h' function to create elements.
+     */
+    render: (props: {
+        lineIndex: number | (() => number);
+        lineContent: string | (() => string);
+        isCursorLine: boolean | (() => boolean);
+    }) => any;
+}
+export interface LineRendererOptions {
+    name: string;
+    priority?: number;
+    render: (props: {
+        lineIndex: number | (() => number);
+        lineContent: string | (() => string);
+        isCursorLine: boolean | (() => boolean);
+        gutterWidth: number | (() => number);
+        leftCol: number | (() => number);
+        viewportWidth: number | (() => number);
+        visualStart?: {
+            x: number;
+            y: number;
+        } | null | (() => {
+            x: number;
+            y: number;
+        } | null);
+        mode?: VimMode | (() => VimMode);
+        cursor?: {
+            x: number;
+            y: number;
+        } | (() => {
+            x: number;
+            y: number;
+        });
+    }) => any;
+}
+export interface VimState {
+    buffer: string[];
+    cursor: {
+        x: number;
+        y: number;
+    };
+    visualStart: {
+        x: number;
+        y: number;
+    } | null;
+    topLine: number;
+    leftCol: number;
+    viewportHeight: number;
+    viewportWidth: number;
+    mode: VimMode;
+    commandText: string;
+    commandCursorX: number;
+    currentFilePath: string | null;
+    isExplorer: boolean;
+    explorerPath: string;
+    isReadOnly: boolean;
+    plugins: any[];
+    gutters: GutterOptions[];
+    lineRenderers: LineRendererOptions[];
+    contextMenuItems: ContextMenuItem[];
+    completionItems: CompletionItem[];
+    selectedCompletionIndex: number;
+    hoverText: string | null;
+    hoverPos: {
+        x: number;
+        y: number;
+    };
+    statusMessage: string | null;
+    wrap: boolean;
+}
+export interface FileSystem {
+    readFile: (path: string) => Promise<string | null>;
+    writeFile: (path: string, content: string) => Promise<void>;
+    listDirectory: (path: string) => Promise<string[]>;
+    isDirectory: (path: string) => Promise<boolean>;
+}
+export interface VimAPI {
+    registerCommand: (name: string, callback: (args: string[]) => void) => void;
+    getBuffer: () => string[];
+    setBuffer: (buffer: string[]) => void;
+    getCursor: () => {
+        x: number;
+        y: number;
+    };
+    setCursor: (x: number, y: number) => void;
+    getVisualStart: () => {
+        x: number;
+        y: number;
+    } | null;
+    getMode: () => VimMode;
+    on: (event: VimEvent, callback: (...args: any[]) => void) => void;
+    executeCommand: (cmd: string) => void;
+    loadPluginFromSource: (name: string, source: string) => Promise<boolean>;
+    registerGutter: (options: GutterOptions) => void;
+    registerLineRenderer: (options: LineRendererOptions) => void;
+    showCompletions: (items: CompletionItem[], onSelect: (item: CompletionItem) => void) => void;
+    hideCompletions: () => void;
+    showHover: (text: string, x: number, y: number) => void;
+    hideHover: () => void;
+    registerContextMenuItem: (item: ContextMenuItem) => void;
+    insertText: (text: string) => void;
+    rerender: () => void;
+    setFS: (fs: FileSystem) => void;
+    getFS: () => FileSystem;
+    resetFS: () => void;
+    babel: any;
+}

package/dist/src/utils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Utility to load a script from a URL
+ */
+export declare function loadScript(url: string): Promise<void>;

package/dist/src/vim-engine.d.ts

@@ -0,0 +1,63 @@
+import { VimAPI, VimState } from './types';
+export declare class VimEngine {
+    private buffer;
+    private cursor;
+    private visualStart;
+    private topLine;
+    private leftCol;
+    private viewportHeight;
+    private viewportWidth;
+    private mode;
+    private commandText;
+    private commandCursorX;
+    private currentFilePath;
+    private isExplorer;
+    private explorerPath;
+    private isReadOnly;
+    private gutters;
+    private lineRenderers;
+    private contextMenuItems;
+    private commands;
+    private onUpdate;
+    private eventListeners;
+    private pluginManager;
+    private fs;
+    private leader;
+    private pendingSequence;
+    private isInitialized;
+    private completionItems;
+    private selectedCompletionIndex;
+    private onCompletionSelect;
+    private hoverText;
+    private hoverPos;
+    private statusMessage;
+    private messageTimeout;
+    private wrap;
+    constructor(onUpdate: () => void);
+    init(): Promise<void>;
+    setUpdateCallback(onUpdate: () => void): void;
+    private registerBuiltinCommands;
+    private openDirectory;
+    private openFile;
+    getAPI(): VimAPI;
+    hideCompletions(): void;
+    setViewportHeight(height: number): void;
+    setViewportWidth(width: number): void;
+    private scrollCursorIntoView;
+    private trigger;
+    loadPluginFromSource(name: string, tsSource: string): Promise<boolean>;
+    setCursor(x: number, y: number): void;
+    getState(): VimState;
+    private showMessage;
+    handleKey(key: string, _ctrl?: boolean): void;
+    private handleExplorerSelect;
+    private moveCursor;
+    private handleNormalMode;
+    private handleInsertMode;
+    private handleVisualMode;
+    private yankToClipboard;
+    private getSelectionText;
+    private deleteSelection;
+    private handleCommandMode;
+    private executeCommand;
+}

package/dist/src/vim-engine.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/wasm/tui_engine.d.ts

@@ -0,0 +1,46 @@
+/* tslint:disable */
+/* eslint-disable */
+export function init_panic_hook(): void;
+export class Engine {
+  free(): void;
+  constructor(width: number, height: number);
+  render(root: any): any;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_engine_free: (a: number, b: number) => void;
+  readonly engine_new: (a: number, b: number) => number;
+  readonly engine_render: (a: number, b: any) => any;
+  readonly init_panic_hook: () => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_4: WebAssembly.Table;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@net-vim/core",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Vim-compatible editor engine and component library for the web.",
   "type": "module",
   "repository": {
@@ -47,15 +47,17 @@
   "scripts": {
     "sync-wasm": "cp -r ../../crates/tui-engine/pkg/* ./src/wasm/",
     "build": "npm run sync-wasm && vite build",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "vitest run"
   },
   "dependencies": {
-    "solid-js": "^1.9.11",
-    "virtual-keyboard": "workspace:*"
+    "@net-vim/virtual-keyboard": "workspace:*",
+    "solid-js": "^1.9.11"
   },
   "devDependencies": {
     "typescript": "~5.9.3",
     "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4",
     "vite-plugin-solid": "^2.11.10",
     "vite-plugin-top-level-await": "^1.6.0",
     "vite-plugin-wasm": "^3.5.0"