@isopodlabs/vscode_utils 0.0.2 → 0.1.0

package/dist/utils.d.ts

@@ -1,91 +0,0 @@
-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 {};

package/dist/utils.js

@@ -1,430 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringParser = exports.CallCombiner = exports.CallCombiner0 = exports.AsyncLazy = exports.Lazy = void 0;
-exports.makeCache = makeCache;
-exports.compare = compare;
-exports.reverse_compare = reverse_compare;
-exports.reverse = reverse;
-exports.merge = merge;
-exports.partition = partition;
-exports.isEmpty = isEmpty;
-exports.clone = clone;
-exports.lowerBound = lowerBound;
-exports.argmin = argmin;
-exports.make = make;
-exports.arrayAppend = arrayAppend;
-exports.arrayRemove = arrayRemove;
-exports.arrayCompare = arrayCompare;
-exports.arrayEqual = arrayEqual;
-exports.arrayRotate = arrayRotate;
-exports.arrayReverse = arrayReverse;
-exports.array_make = array_make;
-exports.eachIterable = eachIterable;
-exports.findIterable = findIterable;
-exports.mapIterable = mapIterable;
-exports.asyncMap = asyncMap;
-exports.asyncReduce = asyncReduce;
-exports.parallel = parallel;
-exports.serial = serial;
-exports.filterIterable = filterIterable;
-exports.asyncFilter = asyncFilter;
-exports.mapObject = mapObject;
-exports.filterObject = filterObject;
-exports.firstOf = firstOf;
-exports.lastOf = lastOf;
-exports.splitFirstOf = splitFirstOf;
-exports.splitLastOf = splitLastOf;
-exports.trim0 = trim0;
-exports.replace = replace;
-exports.async_replace = async_replace;
-exports.replace_back = replace_back;
-exports.async_replace_back = async_replace_back;
-exports.splitEvery = splitEvery;
-exports.tag = tag;
-exports.stringCode = stringCode;
-exports.stringCodeBig = stringCodeBig;
-exports.previousChar = previousChar;
-exports.hasCustomToString = hasCustomToString;
-class Lazy {
-    factory;
-    _value;
-    constructor(factory) {
-        this.factory = factory;
-    }
-    get value() {
-        if (this._value === undefined)
-            this._value = this.factory();
-        return this._value;
-    }
-}
-exports.Lazy = Lazy;
-class AsyncLazy {
-    factory;
-    _value;
-    constructor(factory) {
-        this.factory = factory;
-    }
-    get value() {
-        if (this._value === undefined) {
-            this._value = null;
-            this.factory().then(v => this._value = v);
-        }
-        return this._value;
-    }
-}
-exports.AsyncLazy = AsyncLazy;
-class CallCombiner0 {
-    timeout = null;
-    combine(delay, func) {
-        if (this.timeout)
-            clearTimeout(this.timeout);
-        this.timeout = setTimeout(() => {
-            this.timeout = null;
-            func();
-        }, delay);
-    }
-    pending() {
-        return !!this.timeout;
-    }
-}
-exports.CallCombiner0 = CallCombiner0;
-class CallCombiner extends CallCombiner0 {
-    func;
-    delay;
-    constructor(func, delay) {
-        super();
-        this.func = func;
-        this.delay = delay;
-    }
-    trigger() {
-        super.combine(this.delay, this.func);
-    }
-}
-exports.CallCombiner = CallCombiner;
-function makeCache(load) {
-    const cache = {};
-    return {
-        get: (fullpath) => {
-            if (!cache[fullpath])
-                cache[fullpath] = load(fullpath);
-            return cache[fullpath];
-        },
-        remove: (fullpath) => {
-            delete cache[fullpath];
-        },
-    };
-}
-function compare(a, b) {
-    return a < b ? -1 : a > b ? 1 : 0;
-}
-function reverse_compare(a, b) {
-    return compare(b, a);
-}
-function reverse(func) {
-    return (a, b) => func(b, a);
-}
-function merge(...list) {
-    function isT(value) {
-        return typeof value === 'object' && value !== null;
-    }
-    function recurse(target, source) {
-        for (const key in source) {
-            if (isT(source[key]) && isT(target[key]))
-                recurse(target[key], source[key]);
-            else
-                target[key] = source[key];
-        }
-        return target;
-    }
-    return list.reduce((merged, r) => recurse(merged, r), {});
-}
-function partition(array, func) {
-    const partitions = {};
-    for (const i of array)
-        (partitions[func(i)] ??= []).push(i);
-    return partitions;
-}
-function isEmpty(obj) {
-    return Object.keys(obj).length === 0;
-}
-function clone(obj) {
-    return Object.assign(Object.create(Object.getPrototypeOf(obj)), obj);
-}
-function lowerBound(array, value, func) {
-    let i = 0;
-    for (let n = array.length; n; n >>= 1) {
-        const mid = i + (n >> 1);
-        if (func(array[mid], value, mid)) {
-            i = mid + 1;
-            --n;
-        }
-    }
-    return i;
-}
-function argmin(array, fn) {
-    let mini = 0;
-    let minv = fn ? fn(array[0]) : array[0];
-    for (let i = 1; i < array.length; i++) {
-        const v = fn ? fn(array[i]) : array[i];
-        if (v < minv) {
-            mini = i;
-            minv = v;
-        }
-    }
-    return mini;
-}
-function isConstructor(maker) {
-    return maker.prototype?.constructor.name;
-    //	return typeof maker === 'function' && maker.prototype && !!maker.prototype.constructor;
-}
-function make(maker, arg, opt) {
-    return isConstructor(maker) ? new maker(arg, opt) : maker(arg, opt);
-}
-function arrayAppend(array, items) {
-    for (const i of items)
-        array.push(i);
-}
-function arrayRemove(array, item) {
-    const index = array.indexOf(item);
-    if (index === -1)
-        return false;
-    array.splice(index, 1);
-    return true;
-}
-function arrayCompare(arr1, arr2) {
-    const length = Math.min(arr1.length, arr2.length);
-    for (let i = 0; i < length; i++) {
-        const r = compare(arr1[i], arr2[i]);
-        if (r)
-            return r;
-    }
-    return arr1.length - arr2.length;
-}
-function arrayEqual(arr1, arr2) {
-    if (arr1.length !== arr2.length)
-        return false;
-    for (let i = 0; i < arr1.length; i++) {
-        if (arr1[i] !== arr2[i])
-            return false;
-    }
-    return true;
-}
-function arrayRotate(array, start, end, shift) {
-    const length = end - start;
-    if (length > 1 && shift % length) {
-        shift = ((shift % length) + length) % length;
-        arrayReverse(array, start, end - 1);
-        arrayReverse(array, start, start + shift - 1);
-        arrayReverse(array, start + shift, end - 1);
-    }
-}
-function arrayReverse(array, start, end) {
-    while (start < end) {
-        [array[start], array[end]] = [array[end], array[start]];
-        start++;
-        end--;
-    }
-}
-function array_make(n, constructor) {
-    return Array.from({ length: n }, () => new constructor);
-}
-function eachIterable(iterable, func) {
-    if (iterable) {
-        let i = 0;
-        for (const v of iterable)
-            func(v, i++);
-    }
-}
-function findIterable(iterable, func) {
-    if (iterable) {
-        for (const v of iterable) {
-            if (func(v))
-                return v;
-        }
-    }
-}
-function mapIterable(iterable, func) {
-    return iterable ? Array.from(iterable, func) : [];
-}
-async function asyncMap(iterable, func) {
-    return Promise.all(mapIterable(iterable, func));
-}
-async function asyncReduce(array, func, initialValue) {
-    return array.reduce(async (promise, v, i, array) => func(await promise, v, i, array), Promise.resolve(initialValue));
-}
-async function parallel(...fns) {
-    return asyncMap(fns, f => f());
-}
-async function serial(...fns) {
-    const results = [];
-    for (const f of fns)
-        results.push(await f());
-    return results;
-}
-function filterIterable(iterable, func) {
-    const array = [];
-    let i = 0;
-    for (const v of iterable)
-        if (func(v, i++))
-            array.push(v);
-    return array;
-}
-async function asyncFilter(iterable, func) {
-    const filters = await Promise.all(mapIterable(iterable, func));
-    return filterIterable(iterable, (_, i) => filters[i]);
-}
-function mapObject(obj, func) {
-    return Object.fromEntries(Object.entries(obj).map(x => func(x)));
-}
-function filterObject(obj, func) {
-    return Object.fromEntries(Object.entries(obj).filter(x => func(x)));
-}
-//-----------------------------------------------------------------------------
-//	strings
-//-----------------------------------------------------------------------------
-function firstOf(value, find) {
-    let index = value.length;
-    for (const c of find) {
-        const i = value.indexOf(c);
-        if (i >= 0)
-            index = Math.min(i);
-    }
-    return index;
-}
-function lastOf(value, find) {
-    let index = -1;
-    for (const c of find)
-        index = Math.max(value.indexOf(c));
-    return index;
-}
-function splitFirstOf(value, find) {
-    const index = firstOf(value, find);
-    return index === -1 ? [undefined, value] : [value.substring(0, index), value.substring(index + 1)];
-}
-function splitLastOf(value, find) {
-    const index = lastOf(value, find);
-    return index === -1 ? [value, undefined] : [value.substring(0, index), value.substring(index + 1)];
-}
-function trim0(value) {
-    const index = value.indexOf('\0');
-    return index === -1 ? value : value.substring(0, index);
-}
-function replace(value, re, process) {
-    let m;
-    let result = "";
-    let i = 0;
-    while ((m = re.exec(value))) {
-        result += value.substring(i, m.index) + process(m);
-        i = re.lastIndex;
-    }
-    return result + value.substring(i);
-}
-async function async_replace(value, re, process) {
-    let m;
-    let result = "";
-    let i = 0;
-    while ((m = re.exec(value))) {
-        result += value.substring(i, m.index) + await process(m);
-        i = re.lastIndex;
-    }
-    return result + value.substring(i);
-}
-function replace_back(value, re, process) {
-    const start = re.lastIndex;
-    const m = re.exec(value);
-    if (m) {
-        const right = replace_back(value, re, process);
-        return value.substring(start, m.index) + process(m, right);
-    }
-    re.lastIndex = value.length;
-    return value.substring(start);
-}
-async function async_replace_back(value, re, process) {
-    const start = re.lastIndex;
-    const m = re.exec(value);
-    if (m) {
-        const right = await async_replace_back(value, re, process);
-        return value.substring(start, m.index) + await process(m, right);
-    }
-    re.lastIndex = value.length;
-    return value.substring(start);
-}
-function splitEvery(s, n) {
-    return Array.from({ length: Math.ceil(s.length / n) }, (_, i) => s.slice(i * n, (i + 1) * n));
-}
-function tag(strings, ...keys) {
-    return ((...values) => {
-        const dict = values.at(-1) || {};
-        return keys.map((key, i) => (Number.isInteger(key) ? values[key] : dict[key]) + strings[i + 1]).join('');
-    });
-}
-function stringCode(s) {
-    let r = 0;
-    for (let i = 0; i < s.length; i++)
-        r += s.charCodeAt(i) << (i * 8);
-    return r;
-}
-function stringCodeBig(s) {
-    let r = 0n;
-    for (let i = 0; i < s.length; i++)
-        r += BigInt(s.charCodeAt(i)) << BigInt(i * 8);
-    return r;
-}
-function previousChar(str, pos) {
-    return pos === 0
-        ? "\n"
-        // check for low surrogate (BMP)
-        : (str.charCodeAt(pos - 1) & 0xfc00) === 0xdc00 && (str.charCodeAt(pos - 2) & 0xfc00) === 0xd800
-            ? str.slice(pos - 2, pos) : str.charAt(pos - 1);
-}
-function hasCustomToString(value) {
-    return value && value.toString !== Object.prototype.toString;
-}
-class StringParser {
-    subject;
-    pos;
-    constructor(subject, pos = 0) {
-        this.subject = subject;
-        this.pos = pos;
-    }
-    remaining() { return this.subject.length - this.pos; }
-    remainder() { return this.subject.slice(this.pos); }
-    processed() { return this.subject.slice(0, this.pos); }
-    peek() {
-        return this.subject[this.pos];
-    }
-    peekn(n) {
-        return this.subject.slice(this.pos, this.pos + n);
-    }
-    get(n) {
-        const pos = this.pos;
-        this.pos = Math.min(pos + n, this.subject.length);
-        return this.subject.slice(pos, this.pos);
-    }
-    skip(c) {
-        if (this.remainder().startsWith(c)) {
-            this.pos += c.length;
-            return true;
-        }
-        return false;
-    }
-    expect(c) {
-        if (!this.skip(c))
-            throw new Error(`Expected '${c}'`);
-    }
-    match(re) {
-        const m = re.exec(this.remainder());
-        if (m) {
-            this.pos += m.index + m[0].length;
-            return m[0];
-        }
-    }
-    exec(re) {
-        const m = re.exec(this.remainder());
-        if (m) {
-            this.pos += m.index + m[0].length;
-            return m;
-        }
-    }
-}
-exports.StringParser = StringParser;