@isopodlabs/vscode_utils 0.0.2

package/dist/utils.js

@@ -0,0 +1,430 @@
+"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;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@isopodlabs/vscode_utils",
+  "version": "0.0.2",
+  "description": "vscode utilities",
+  "main": "dist/utils.js",
+  "files": [
+    "dist",
+    "assets",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"No tests specified\" && exit 0"
+  },
+  "keywords": [
+    "vscode",
+    "typescript"
+  ],
+  "author": "Adrian Stephens",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.13.8",
+    "eslint": "^9.21.0",
+    "typescript": "^5.8.2",
+    "typescript-eslint": "^8.26.0"
+  },
+  "dependencies": {
+    "@types/vscode": "^1.98.0"
+  }
+}