@isopodlabs/vscode_utils 0.0.2

package/dist/icon-theme.js

@@ -0,0 +1,199 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IconTheme = void 0;
+exports.getLanguage = getLanguage;
+exports.getIconTheme = getIconTheme;
+exports.loadIconTheme = loadIconTheme;
+const vscode = __importStar(require("vscode"));
+const path = __importStar(require("path"));
+function getLanguage(ext) {
+    const ext2 = ext[0] == '.' ? ext.slice(1) : '.' + ext;
+    for (const extension of vscode.extensions.all) {
+        const languages = extension.packageJSON.contributes?.languages;
+        if (languages) {
+            for (const lang of languages) {
+                if (lang.extensions?.includes(ext) || lang.extensions?.includes(ext2))
+                    return lang.id;
+            }
+        }
+    }
+}
+class IconTheme {
+    themeFolder;
+    theme;
+    constructor(themeFolder, theme) {
+        this.themeFolder = themeFolder;
+        this.theme = theme;
+        for (const def of Object.values(theme.iconDefinitions)) {
+            if ('fontCharacter' in def)
+                def.fontCharacter = String.fromCharCode(parseInt(def.fontCharacter.slice(1), 16));
+        }
+    }
+    getUri(webview, file) {
+        return webview.asWebviewUri(vscode.Uri.file(path.join(this.themeFolder.fsPath, file)));
+    }
+    style(webview) {
+        return this.theme.fonts ? this.theme.fonts.map(f => `@font-face {
+				font-family: '${f.id}';
+				src: ${f.src.map(s => `url('${this.getUri(webview, s.path)}') format('${s.format}')`).join(', ')};
+				font-weight: ${f.weight};
+				font-style: ${f.style};
+			}
+			[font=${f.id}]::before {
+				font-family: ${f.id};
+				font-size: ${f.size};
+			}
+			`).join('\n') : '';
+    }
+    csp(webview) {
+        return webview.asWebviewUri(this.themeFolder);
+    }
+    get_def(webview, icon) {
+        if (icon) {
+            const def = this.theme.iconDefinitions[icon];
+            if (def) {
+                if ('iconPath' in def)
+                    return {
+                        icon: this.getUri(webview, def.iconPath)
+                    };
+                return {
+                    font: def.fontId || this.theme.fonts[0].id,
+                    icon: def.fontCharacter,
+                    ...(def.fontColor ? { style: `--icon-color: ${def.fontColor}` } : {})
+                };
+            }
+        }
+    }
+    getLanguageIcon(ext) {
+        const lang = getLanguage(ext);
+        return lang && this.theme.languageIds[lang];
+    }
+    getFileIcon(name) {
+        let icon = this.theme.fileNames[name];
+        if (!icon && (this.theme.fileExtensions || this.theme.languageIds)) {
+            const exts = name.split('.');
+            while (!icon && exts.length > 1) {
+                exts.shift();
+                const ext = exts.join('.');
+                if (this.theme.languageIds && (icon = this.getLanguageIcon(ext)))
+                    return icon;
+                icon = this.theme.fileExtensions?.[ext];
+            }
+        }
+        return icon || this.theme.file;
+    }
+    getFolderIcon(name, expanded = false) {
+        return (expanded && this.theme.folderNamesExpanded?.[name])
+            || this.theme.folderNames?.[name]
+            || (expanded && this.theme.folderExpanded)
+            || this.theme.folder;
+    }
+    getRootFolderIcon(name, expanded = false) {
+        return (expanded && this.theme.rootFolderNamesExpanded?.[name])
+            || this.theme.rootFolderNames?.[name]
+            || (expanded && this.theme.folderNamesExpanded?.[name])
+            || this.theme.folderNames?.[name]
+            || (expanded && this.theme.rootFolderExpanded)
+            || this.theme.rootFolder
+            || (expanded && this.theme.folderExpanded)
+            || this.theme.folder;
+    }
+    getFileIconForUri(uri) {
+        const comps = uri.fsPath.split(path.sep);
+        const last = comps.at(-1);
+        let icon = this.theme.fileNames[comps.slice(-2).join('/')] || this.theme.fileNames[last];
+        if (!icon && (this.theme.fileExtensions || this.theme.languageIds)) {
+            const exts = last.split('.');
+            const dir = comps.at(-2);
+            while (!icon && exts.length > 1) {
+                exts.shift();
+                const ext = exts.join('.');
+                if (this.theme.languageIds && (icon = this.getLanguageIcon(ext)))
+                    return icon;
+                if (this.theme.fileExtensions)
+                    icon = this.theme.fileExtensions[ext] || this.theme.fileExtensions[`${dir}/${ext}`];
+            }
+        }
+        return icon || this.theme.file;
+    }
+    getFolderIconForUri(uri, expanded = false, root) {
+        if (root && uri.fsPath.startsWith(root.fsPath))
+            return this.getRootFolderIcon(root.fsPath.slice(root.fsPath.length), expanded);
+        const comps = uri.fsPath.split(path.sep);
+        const last = comps.at(-1);
+        const last2 = comps.slice(-2).join('/');
+        return (expanded ? this.theme.folderNamesExpanded?.[last2] : this.theme.folderNames?.[last2])
+            || this.getFolderIcon(last, expanded);
+    }
+    async copyAssets(dest, changeFolder = false) {
+        const srce = this.themeFolder;
+        function copy(name) {
+            return vscode.workspace.fs.copy(vscode.Uri.joinPath(srce, name), vscode.Uri.joinPath(dest, name), { overwrite: true });
+        }
+        if (this.theme.iconDefinitions) {
+            for (const def of Object.values(this.theme.iconDefinitions)) {
+                if ('iconPath' in def)
+                    await copy(def.iconPath);
+            }
+        }
+        if (this.theme.fonts) {
+            for (const font of this.theme.fonts) {
+                for (const src of font.src) {
+                    if (src.path)
+                        await copy(src.path);
+                }
+            }
+        }
+        if (changeFolder)
+            this.themeFolder = dest;
+    }
+}
+exports.IconTheme = IconTheme;
+function getIconTheme(id) {
+    for (const extension of vscode.extensions.all) {
+        const themes = extension.packageJSON.contributes?.iconThemes;
+        const theme = themes && themes.find((theme) => theme.id === id);
+        if (theme)
+            return vscode.Uri.joinPath(extension.extensionUri, theme.path);
+    }
+}
+async function loadIconTheme() {
+    const theme = vscode.workspace.getConfiguration("workbench").get("iconTheme");
+    const source = theme && getIconTheme(theme);
+    if (source) {
+        return new IconTheme(source.with({ path: path.dirname(source.path) }), await vscode.workspace.fs.readFile(source).then(buffer => JSON.parse(buffer.toString()), () => ({})));
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,91 @@
+export declare class Lazy<T> {
+    private factory;
+    private _value;
+    constructor(factory: () => T);
+    get value(): T;
+}
+export declare class AsyncLazy<T> {
+    private factory;
+    private _value;
+    constructor(factory: () => Promise<T>);
+    get value(): (T & {}) | null;
+}
+export declare class CallCombiner0 {
+    private timeout;
+    combine(delay: number, func: () => void): void;
+    pending(): boolean;
+}
+export declare class CallCombiner extends CallCombiner0 {
+    private func;
+    private delay;
+    constructor(func: () => void, delay: number);
+    trigger(): void;
+}
+export declare function makeCache<T>(load: (key: string) => T): {
+    get: (fullpath: string) => T;
+    remove: (fullpath: string) => void;
+};
+export declare function compare<T>(a: T, b: T): number;
+export declare function reverse_compare<T>(a: T, b: T): number;
+export declare function reverse<T, R>(func: (a: T, b: T) => R): (a: T, b: T) => R;
+export declare function merge(...list: Record<string, any>[]): Record<string, any>;
+type PartitionIndex<U> = U extends boolean ? 'true' | 'false' : U;
+export declare function partition<T, U extends keyof any | boolean>(array: Iterable<T>, func: (v: T) => U): Record<PartitionIndex<U>, T[]>;
+export declare function isEmpty(obj: object): boolean;
+export declare function clone<T extends object>(obj: T): T;
+export declare function lowerBound<T>(array: T[], value: T, func: (a: T, b: T, i: number) => boolean): number;
+export declare function argmin<T>(array: T[], fn?: (i: T) => number): number;
+type Constructor<T, D, O = void> = new (arg: T, opt: O) => D;
+type Factory<T, D, O = void> = (arg: T, opt: O) => D;
+export type ClassOrFactory<T, D, O = void> = Constructor<T, D, O> | Factory<T, D, O>;
+export declare function make<T, D, O>(maker: ClassOrFactory<T, D, O>, arg: T, opt?: O): D;
+export type SpreadType<T> = T extends Iterable<infer U> ? U[] : never;
+export declare function arrayAppend<T, U extends Iterable<T>>(array: T[], items: U): void;
+export declare function arrayRemove<T>(array: T[], item: T): boolean;
+export declare function arrayCompare<T>(arr1: T[], arr2: T[]): number;
+export declare function arrayEqual<T>(arr1: T[], arr2: T[]): boolean;
+export declare function arrayRotate<T>(array: T[], start: number, end: number, shift: number): void;
+export declare function arrayReverse<T>(array: T[], start: number, end: number): void;
+export declare function array_make<T>(n: number, constructor: new () => T): T[];
+export declare function eachIterable<T>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => void): void;
+export declare function findIterable<T>(iterable: Iterable<T> | undefined, func: (v: T) => boolean): T | undefined;
+export declare function mapIterable<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => U): U[];
+export declare function asyncMap<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => Promise<U>): Promise<U[]>;
+export declare function asyncReduce<T, U>(array: T[], func: (acc: U, v: T, i: number, array: T[]) => Promise<U>, initialValue: U): Promise<U>;
+export declare function parallel(...fns: (() => any)[]): Promise<any[]>;
+export declare function serial(...fns: (() => any)[]): Promise<any[]>;
+export declare function filterIterable<T>(iterable: Iterable<T>, func: (v: T, i: number) => boolean): T[];
+export declare function asyncFilter<T>(iterable: Iterable<T>, func: (v: T) => Promise<boolean>): Promise<T[]>;
+export declare function mapObject<T, U>(obj: Record<string, T>, func: (x: [k: string, v: T]) => [k: string, v: U]): Record<string, U>;
+export declare function filterObject<T>(obj: Record<string, T>, func: (x: [k: string, v: T]) => boolean): Record<string, T>;
+export declare function firstOf(value: string, find: string): number;
+export declare function lastOf(value: string, find: string): number;
+export declare function splitFirstOf(value: string, find: string): (string | undefined)[];
+export declare function splitLastOf(value: string, find: string): (string | undefined)[];
+export declare function trim0(value: string): string;
+export declare function replace(value: string, re: RegExp, process: (match: RegExpExecArray) => string): string;
+export declare function async_replace(value: string, re: RegExp, process: (match: RegExpExecArray) => Promise<string>): Promise<string>;
+export declare function replace_back(value: string, re: RegExp, process: (match: RegExpExecArray, right: string) => string): string;
+export declare function async_replace_back(value: string, re: RegExp, process: (match: RegExpExecArray, right: string) => Promise<string>): Promise<string>;
+export declare function splitEvery(s: string, n: number): string[];
+export declare function tag(strings: TemplateStringsArray, ...keys: any[]): (...values: any[]) => string;
+export declare function stringCode(s: string): number;
+export declare function stringCodeBig(s: string): bigint;
+export declare function previousChar(str: string, pos: number): string;
+export declare function hasCustomToString(value: any): boolean;
+export declare class StringParser {
+    subject: string;
+    pos: number;
+    constructor(subject: string, pos?: number);
+    remaining(): number;
+    remainder(): string;
+    processed(): string;
+    peek(): string;
+    peekn(n: number): string;
+    get(n: number): string;
+    skip(c: string): boolean;
+    expect(c: string): void;
+    match(re: RegExp): string | undefined;
+    exec(re: RegExp): RegExpExecArray | undefined;
+}
+export {};