@joinezco/codeblock 0.0.8

package/dist/lsps/index.js

@@ -0,0 +1,198 @@
+import { StreamLanguage } from '@codemirror/language';
+const languageSupportCache = {};
+const languageSupportMap = {
+    javascript: async () => {
+        const { javascript } = await import('@codemirror/lang-javascript');
+        return javascript({ jsx: true, typescript: true });
+    },
+    python: async () => {
+        const { python } = await import('@codemirror/lang-python');
+        return python();
+    },
+    rust: async () => {
+        const { rust } = await import('@codemirror/lang-rust');
+        return rust();
+    },
+    html: async () => {
+        const { html } = await import('@codemirror/lang-html');
+        return html();
+    },
+    css: async () => {
+        const { css } = await import('@codemirror/lang-css');
+        return css();
+    },
+    scss: async () => {
+        const { sass } = await import('@codemirror/lang-sass');
+        return sass({ indented: false });
+    },
+    less: async () => {
+        const { less } = await import('@codemirror/lang-less');
+        return less();
+    },
+    json: async () => {
+        const { json } = await import('@codemirror/lang-json');
+        return json();
+    },
+    xml: async () => {
+        const { xml } = await import('@codemirror/lang-xml');
+        return xml();
+    },
+    markdown: async () => {
+        const { markdown } = await import('@codemirror/lang-markdown');
+        return markdown();
+    },
+    sql: async () => {
+        const { sql } = await import('@codemirror/lang-sql');
+        return sql();
+    },
+    php: async () => {
+        const { php } = await import('@codemirror/lang-php');
+        return php();
+    },
+    java: async () => {
+        const { java } = await import('@codemirror/lang-java');
+        return java();
+    },
+    cpp: async () => {
+        const { cpp } = await import('@codemirror/lang-cpp');
+        return cpp();
+    },
+    c: async () => {
+        const { cpp } = await import('@codemirror/lang-cpp');
+        return cpp();
+    },
+    yaml: async () => {
+        const { yaml } = await import('@codemirror/lang-yaml');
+        return yaml();
+    },
+    // Legacy modes
+    ruby: async () => {
+        const { ruby } = await import('@codemirror/legacy-modes/mode/ruby');
+        return StreamLanguage.define(ruby);
+    },
+    csharp: async () => {
+        const { csharp } = await import('@codemirror/legacy-modes/mode/clike');
+        return StreamLanguage.define(csharp);
+    },
+    go: async () => {
+        const { go } = await import('@codemirror/legacy-modes/mode/go');
+        return StreamLanguage.define(go);
+    },
+    swift: async () => {
+        const { swift } = await import('@codemirror/legacy-modes/mode/swift');
+        return StreamLanguage.define(swift);
+    },
+    kotlin: async () => {
+        const { kotlin } = await import('@codemirror/legacy-modes/mode/clike');
+        return StreamLanguage.define(kotlin);
+    },
+    scala: async () => {
+        const { scala } = await import('@codemirror/legacy-modes/mode/clike');
+        return StreamLanguage.define(scala);
+    },
+    vb: async () => {
+        const { vb } = await import('@codemirror/legacy-modes/mode/vb');
+        return StreamLanguage.define(vb);
+    },
+    haskell: async () => {
+        const { haskell } = await import('@codemirror/legacy-modes/mode/haskell');
+        return StreamLanguage.define(haskell);
+    },
+    lua: async () => {
+        const { lua } = await import('@codemirror/legacy-modes/mode/lua');
+        return StreamLanguage.define(lua);
+    },
+    perl: async () => {
+        const { perl } = await import('@codemirror/legacy-modes/mode/perl');
+        return StreamLanguage.define(perl);
+    },
+    bash: async () => {
+        const { shell } = await import('@codemirror/legacy-modes/mode/shell');
+        return StreamLanguage.define(shell);
+    },
+    toml: async () => {
+        const { toml } = await import('@codemirror/legacy-modes/mode/toml');
+        return StreamLanguage.define(toml);
+    },
+    ini: async () => {
+        const { properties } = await import('@codemirror/legacy-modes/mode/properties');
+        return StreamLanguage.define(properties);
+    },
+    dockerfile: async () => {
+        const { dockerFile } = await import('@codemirror/legacy-modes/mode/dockerfile');
+        return StreamLanguage.define(dockerFile);
+    },
+    makefile: async () => {
+        const { cmake } = await import('@codemirror/legacy-modes/mode/cmake');
+        return StreamLanguage.define(cmake);
+    },
+    gitignore: async () => {
+        const { properties } = await import('@codemirror/legacy-modes/mode/properties');
+        return StreamLanguage.define(properties);
+    }
+};
+export const getLanguageSupport = async (language) => {
+    if (languageSupportCache[language]) {
+        return languageSupportCache[language];
+    }
+    const loader = languageSupportMap[language];
+    const support = await loader();
+    languageSupportCache[language] = support;
+    return support;
+};
+export const extOrLanguageToLanguageId = {
+    javascript: 'javascript',
+    js: 'javascript',
+    typescript: 'javascript',
+    ts: 'javascript',
+    jsx: 'javascript',
+    tsx: 'javascript',
+    python: 'python',
+    py: 'python',
+    ruby: 'ruby',
+    rb: 'ruby',
+    php: 'php',
+    java: 'java',
+    cpp: 'cpp',
+    c: 'c',
+    csharp: 'csharp',
+    cs: 'csharp',
+    go: 'go',
+    swift: 'swift',
+    kotlin: 'kotlin',
+    kt: 'kotlin',
+    rust: 'rust',
+    rs: 'rust',
+    scala: 'scala',
+    vb: 'vb',
+    haskell: 'haskell',
+    hs: 'haskell',
+    lua: 'lua',
+    perl: 'perl',
+    pl: 'perl',
+    bash: 'bash',
+    shell: 'bash',
+    sh: 'bash',
+    zsh: 'bash',
+    mysql: 'sql',
+    sql: 'sql',
+    html: 'html',
+    css: 'css',
+    scss: 'scss',
+    less: 'less',
+    json: 'json',
+    yaml: 'yaml',
+    yml: 'yaml',
+    xml: 'xml',
+    markdown: 'markdown',
+    md: 'markdown',
+    toml: 'toml',
+    ini: 'ini',
+    conf: 'ini',
+    log: 'ini',
+    env: 'ini',
+    dockerfile: 'dockerfile',
+    makefile: 'makefile',
+    dockerignore: 'gitignore',
+    gitignore: 'gitignore',
+};

package/dist/lsps/typescript.d.ts

@@ -0,0 +1,55 @@
+import { VfsInterface } from '../types';
+import { Connection } from '@volar/language-server/browser';
+export type CreateTypescriptEnvironmentArgs = {
+    connection: Connection;
+    fs: VfsInterface;
+};
+export declare const createLanguageServer: ({ connection, fs }: CreateTypescriptEnvironmentArgs) => Promise<{
+    initializeParams: import("vscode-languageserver-protocol").InitializeParams;
+    project: import("@volar/language-server").LanguageServerProject;
+    languageServicePlugins: import("@volar/language-service").LanguageServicePlugin<any>[];
+    initialize(params: import("vscode-languageserver-protocol").InitializeParams, project: import("@volar/language-server").LanguageServerProject, languageServicePlugins: import("@volar/language-service").LanguageServicePlugin[]): import("vscode-languageserver-protocol").InitializeResult<import("@volar/language-server").ExperimentalFeatures>;
+    initialized(): void;
+    shutdown(): void;
+    configurations: {
+        get: <T>(section: string, scopeUri?: string) => Promise<T | undefined>;
+        onDidChange: (cb: import("vscode-languageserver-protocol").NotificationHandler<import("vscode-languageserver-protocol").DidChangeConfigurationParams>) => {
+            dispose(): void;
+        };
+    };
+    editorFeatures: void;
+    documents: {
+        all: () => import("@volar/language-server/lib/utils/snapshotDocument").SnapshotDocument[];
+        onDidChangeContent: import("vscode-languageserver-protocol").Event<import("vscode-languageserver").TextDocumentChangeEvent<import("@volar/language-server/lib/utils/snapshotDocument").SnapshotDocument>>;
+        onDidOpen: import("vscode-languageserver-protocol").Event<import("vscode-languageserver").TextDocumentChangeEvent<import("@volar/language-server/lib/utils/snapshotDocument").SnapshotDocument>>;
+        onDidClose: import("vscode-languageserver-protocol").Event<import("vscode-languageserver").TextDocumentChangeEvent<import("@volar/language-server/lib/utils/snapshotDocument").SnapshotDocument>>;
+        onDidSave: import("vscode-languageserver-protocol").Event<import("vscode-languageserver").TextDocumentChangeEvent<import("@volar/language-server/lib/utils/snapshotDocument").SnapshotDocument>>;
+        get(uri: import("vscode-uri").URI): import("@volar/language-server/lib/utils/snapshotDocument").SnapshotDocument | undefined;
+    };
+    workspaceFolders: {
+        readonly all: import("vscode-uri").URI[];
+        has(uri: import("vscode-uri").URI): boolean;
+        onDidChange: (cb: import("vscode-languageserver-protocol").NotificationHandler<import("vscode-languageserver-protocol").WorkspaceFoldersChangeEvent>) => {
+            dispose(): void;
+        };
+    };
+    fileWatcher: {
+        watchFiles: (patterns: string[]) => Promise<import("vscode-languageserver-protocol").Disposable>;
+        onDidChangeWatchedFiles: (cb: import("vscode-languageserver-protocol").NotificationHandler<import("vscode-languageserver-protocol").DidChangeWatchedFilesParams>) => {
+            dispose: () => void;
+        };
+    };
+    languageFeatures: {
+        requestRefresh: (clearDiagnostics: boolean) => Promise<void>;
+    };
+    fileSystem: {
+        readFile(uri: import("vscode-uri").URI): string | Thenable<string | undefined>;
+        stat(uri: import("vscode-uri").URI): import("@volar/language-service").FileStat | Thenable<import("@volar/language-service").FileStat | undefined>;
+        readDirectory(uri: import("vscode-uri").URI): import("@volar/language-service").ProviderResult<[string, import("@volar/language-service").FileType][]>;
+        install(scheme: string, provider: import("@volar/language-service").FileSystem): void;
+    };
+    env: import("@volar/language-server").LanguageServerEnvironment;
+    connection: Connection;
+    onInitialize(callback: (serverCapabilities: import("vscode-languageserver-protocol").ServerCapabilities<import("@volar/language-server").ExperimentalFeatures>) => void): void;
+    onInitialized(callback: () => void): void;
+}>;

package/dist/lsps/typescript.js

@@ -0,0 +1,48 @@
+import { create as createTypeScriptServicePlugins } from 'volar-service-typescript';
+import { createServerBase, createTypeScriptProject } from '@volar/language-server/browser';
+import ts from 'typescript';
+import { VolarFs } from '../utils/fs';
+function getLanguageServicePlugins(_ts) {
+    const plugins = [
+        // @ts-ignore
+        ...createTypeScriptServicePlugins(_ts),
+        // ...more?
+    ];
+    return plugins;
+}
+export const createLanguageServer = async ({ connection, fs }) => {
+    const server = createServerBase(connection, {
+        timer: {
+            setImmediate: (callback, ...args) => {
+                setTimeout(callback, 0, ...args);
+            },
+        },
+    });
+    server.fileSystem.install('file', new VolarFs(fs));
+    server.onInitialize((params) => {
+        console.debug('ts server on init', params);
+    });
+    connection.onShutdown(() => {
+        console.debug('ts server shutdown');
+    });
+    connection.onInitialize(async (params) => {
+        const languageServicePlugins = getLanguageServicePlugins(ts);
+        return server.initialize(params, createTypeScriptProject(
+        // @ts-ignore
+        ts, undefined, async () => ({
+            // rootUri: params.rootUri,
+            languagePlugins: []
+        })), languageServicePlugins);
+    });
+    connection.onInitialized(() => {
+        server.initialized();
+        const extensions = [
+            '.tsx',
+            '.jsx',
+            '.js',
+            '.ts'
+        ];
+        server.fileWatcher.watchFiles([`**/*.{${extensions.join(',')}}`]);
+    });
+    return server;
+};

package/dist/panels/toolbar.d.ts

@@ -0,0 +1,20 @@
+import { EditorView, Panel } from "@codemirror/view";
+import { StateField } from "@codemirror/state";
+import { HighlightedSearch } from "../utils/search";
+export interface CommandResult {
+    id: string;
+    type: 'create-file' | 'rename-file';
+    icon: string;
+    query: string;
+    requiresInput?: boolean;
+}
+export type SearchResult = HighlightedSearch | CommandResult;
+export interface NamingMode {
+    active: boolean;
+    type: 'create-file' | 'rename-file';
+    originalQuery: string;
+    languageExtension?: string;
+}
+export declare const setSearchResults: import("@codemirror/state").StateEffectType<SearchResult[]>;
+export declare const searchResultsField: StateField<SearchResult[]>;
+export declare const toolbarPanel: (view: EditorView) => Panel;