@vinicunca/perkakas 0.2.1 → 0.3.1

package/dist/es/string/cases.js

@@ -0,0 +1,93 @@
+import { isString } from '../guard/is-string';
+const RE_NUMBER_CHAR = /\d/;
+const STR_SPLITTERS = ['-', '_', '/', '.'];
+export function isUppercase(char = '') {
+    if (RE_NUMBER_CHAR.test(char)) {
+        return undefined;
+    }
+    return char !== char.toLowerCase();
+}
+export function splitByCase(str, separators) {
+    const splitters = separators ?? STR_SPLITTERS;
+    const parts = [];
+    if (!str || !isString(str)) {
+        return parts;
+    }
+    let buff = '';
+    let previousUpper;
+    let previousSplitter;
+    for (const char of str) {
+        const isSplitter = splitters.includes(char);
+        if (isSplitter === true) {
+            parts.push(buff);
+            buff = '';
+            previousUpper = undefined;
+            continue;
+        }
+        const isUpper = isUppercase(char);
+        if (previousSplitter === false) {
+            if (previousUpper === false && isUpper === true) {
+                parts.push(buff);
+                buff = char;
+                previousUpper = isUpper;
+                continue;
+            }
+            if (previousUpper === true && isUpper === false && buff.length > 1) {
+                const lastChar = buff.at(-1);
+                parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+                buff = lastChar + char;
+                previousUpper = isUpper;
+                continue;
+            }
+        }
+        buff += char;
+        previousUpper = isUpper;
+        previousSplitter = isSplitter;
+    }
+    parts.push(buff);
+    return parts;
+}
+export function toUpperFirst(str) {
+    return (str ? str[0]?.toUpperCase() + str.slice(1) : '');
+}
+export function toLowerFirst(str) {
+    return (str ? str[0]?.toLowerCase() + str.slice(1) : '');
+}
+export function toPascalCase(str, opts) {
+    return str
+        ? (Array.isArray(str) ? str : splitByCase(str))
+            .map((p) => toUpperFirst(opts?.normalize ? p.toLowerCase() : p))
+            .join('')
+        : '';
+}
+export function toCamelCase(str, opts) {
+    return toLowerFirst(toPascalCase(str || '', opts));
+}
+export function toKebabCase(str, joiner) {
+    return str
+        ? (Array.isArray(str) ? str : splitByCase(str))
+            .map((p) => p.toLowerCase())
+            .join(joiner ?? '-')
+        : '';
+}
+export function toSnakeCase(str) {
+    return toKebabCase(str || '', '_');
+}
+export function toFlatCase(str) {
+    return toKebabCase(str || '', '');
+}
+export function toTrainCase(str, opts) {
+    return (Array.isArray(str) ? str : splitByCase(str))
+        .filter(Boolean)
+        .map((p) => toUpperFirst(opts?.normalize ? p.toLowerCase() : p))
+        .join('-');
+}
+const titleCaseExceptions = /^(a|an|and|as|at|but|by|for|if|in|is|nor|of|on|or|the|to|with)$/i;
+export function toTitleCase(str, opts) {
+    return (Array.isArray(str) ? str : splitByCase(str))
+        .filter(Boolean)
+        .map((p) => titleCaseExceptions.test(p)
+        ? p.toLowerCase()
+        : toUpperFirst(opts?.normalize ? p.toLowerCase() : p))
+        .join(' ');
+}

package/dist/es/string/human-readable-file-size.js

@@ -0,0 +1,12 @@
+export function humanReadableFileSize(bytes, base = 1000) {
+    if (bytes < base) {
+        return `${bytes} B`;
+    }
+    const prefix = base === 1024 ? ['Ki', 'Mi', 'Gi'] : ['k', 'M', 'G'];
+    let unit = -1;
+    while (Math.abs(bytes) >= base && unit < prefix.length - 1) {
+        bytes /= base;
+        ++unit;
+    }
+    return `${bytes.toFixed(1)} ${prefix[unit]}B`;
+}

package/dist/es/string/index.js

@@ -0,0 +1,5 @@
+export * from './cases';
+export * from './human-readable-file-size';
+export * from './random-string';
+export * from './slugify';
+export * from './string-to-path';

package/dist/es/string/random-string.js

@@ -0,0 +1,6 @@
+import { range } from '../array/range';
+export function randomString(length) {
+    const characterSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const randomChar = () => characterSet[Math.floor(Math.random() * characterSet.length)];
+    return range(0, length).reduce((text) => text + randomChar(), '');
+}

package/dist/es/string/slugify.js

@@ -0,0 +1,9 @@
+export function slugify(str) {
+    return str
+        .normalize('NFD')
+        .replace(/[\u0300-\u036F]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, ' ')
+        .trim()
+        .replace(/\s+/g, '-');
+}

package/dist/es/string/string-to-path.js

@@ -0,0 +1,14 @@
+export function stringToPath(path) {
+    return _stringToPath(path);
+}
+function _stringToPath(path) {
+    if (path.length === 0) {
+        return [];
+    }
+    const match = path.match(/^\[(.+?)\](.*)$/) ?? path.match(/^\.?([^.[\]]+)(.*)$/);
+    if (match) {
+        const [, key, rest] = match;
+        return [key, ..._stringToPath(rest)];
+    }
+    return [path];
+}

package/dist/es/type/index.js

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

package/dist/es/type/type.js

@@ -0,0 +1,9 @@
+export function type(val) {
+    if (val === null) {
+        return 'Null';
+    }
+    if (val === undefined) {
+        return 'Undefined';
+    }
+    return Object.prototype.toString.call(val).slice(8, -1);
+}

package/dist/es/utils/heap.js

@@ -0,0 +1,38 @@
+import { hasAtLeast } from '../array/has-at-least';
+import { swapInPlace } from './swap-in-place';
+export function heapify(heap, compareFn) {
+    for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {
+        heapSiftDown(heap, i, compareFn);
+    }
+}
+export function heapMaybeInsert(heap, compareFn, item) {
+    if (!hasAtLeast(heap, 1)) {
+        return;
+    }
+    const head = heap[0];
+    if (compareFn(item, head) >= 0) {
+        return;
+    }
+    heap[0] = item;
+    heapSiftDown(heap, 0, compareFn);
+    return head;
+}
+function heapSiftDown(heap, index, compareFn) {
+    let currentIndex = index;
+    while (currentIndex * 2 + 1 < heap.length) {
+        const firstChildIndex = currentIndex * 2 + 1;
+        let swapIndex = compareFn(heap[currentIndex], heap[firstChildIndex]) < 0
+            ? firstChildIndex
+            : currentIndex;
+        const secondChildIndex = firstChildIndex + 1;
+        if (secondChildIndex < heap.length
+            && compareFn(heap[swapIndex], heap[secondChildIndex]) < 0) {
+            swapIndex = secondChildIndex;
+        }
+        if (swapIndex === currentIndex) {
+            return;
+        }
+        swapInPlace(heap, currentIndex, swapIndex);
+        currentIndex = swapIndex;
+    }
+}

package/dist/es/utils/narrow.js

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

package/dist/es/utils/paths.js

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

package/dist/es/utils/purry-on.js

@@ -0,0 +1,6 @@
+export function purryOn(isArg, implementation, args) {
+    const callArgs = Array.from(args);
+    return isArg(args[0])
+        ? (data) => implementation(data, ...callArgs)
+        : implementation(...callArgs);
+}

package/dist/es/utils/purry-order-rules.js

@@ -0,0 +1,61 @@
+const COMPARATORS = {
+    asc: (x, y) => x > y,
+    desc: (x, y) => x < y,
+};
+export function purryOrderRules(func, inputArgs) {
+    const [dataOrRule, ...rules] = (Array.isArray(inputArgs) ? inputArgs : Array.from(inputArgs));
+    if (!isOrderRule(dataOrRule)) {
+        const compareFn = orderRuleComparer(...rules);
+        return func(dataOrRule, compareFn);
+    }
+    const compareFn = orderRuleComparer(dataOrRule, ...rules);
+    return (data) => func(data, compareFn);
+}
+export function purryOrderRulesWithArgument(func, inputArgs) {
+    const [first, second, ...rest] = Array.from(inputArgs);
+    let arg;
+    let argRemoved;
+    if (isOrderRule(second)) {
+        arg = first;
+        argRemoved = [second, ...rest];
+    }
+    else {
+        arg = second;
+        argRemoved = [first, ...rest];
+    }
+    return purryOrderRules((...args) => func(...args, arg), argRemoved);
+}
+function orderRuleComparer(primaryRule, secondaryRule, ...otherRules) {
+    const projector = typeof primaryRule === 'function' ? primaryRule : primaryRule[0];
+    const direction = typeof primaryRule === 'function' ? 'asc' : primaryRule[1];
+    const comparator = COMPARATORS[direction];
+    const nextComparer = secondaryRule === undefined
+        ? undefined
+        : orderRuleComparer(secondaryRule, ...otherRules);
+    return (a, b) => {
+        const projectedA = projector(a);
+        const projectedB = projector(b);
+        if (comparator(projectedA, projectedB)) {
+            return 1;
+        }
+        if (comparator(projectedB, projectedA)) {
+            return -1;
+        }
+        return nextComparer?.(a, b) ?? 0;
+    };
+}
+function isOrderRule(x) {
+    if (isProjection(x)) {
+        return true;
+    }
+    if (typeof x !== 'object' || !Array.isArray(x)) {
+        return false;
+    }
+    const [maybeProjection, maybeDirection, ...rest] = x;
+    return (isProjection(maybeProjection)
+        && maybeDirection in COMPARATORS
+        && rest.length === 0);
+}
+function isProjection(x) {
+    return typeof x === 'function' && x.length === 1;
+}

package/dist/es/utils/quick-select.js

@@ -0,0 +1,27 @@
+import { swapInPlace } from './swap-in-place';
+export function quickSelect(data, index, compareFn) {
+    return index < 0 || index >= data.length
+        ? undefined
+        : quickSelectImplementation([...data], 0, data.length - 1, index, compareFn);
+}
+function quickSelectImplementation(data, left, right, index, compareFn) {
+    if (left === right) {
+        return data[left];
+    }
+    const pivotIndex = partition(data, left, right, compareFn);
+    return index === pivotIndex
+        ? data[index]
+        : quickSelectImplementation(data, index < pivotIndex ? left : pivotIndex + 1, index < pivotIndex ? pivotIndex - 1 : right, index, compareFn);
+}
+function partition(data, left, right, compareFn) {
+    const pivot = data[right];
+    let i = left;
+    for (let j = left; j < right; j++) {
+        if (compareFn(data[j], pivot) < 0) {
+            swapInPlace(data, i, j);
+            i++;
+        }
+    }
+    swapInPlace(data, i, right);
+    return i;
+}

package/dist/es/utils/reduce-lazy.js

@@ -0,0 +1,14 @@
+export function reduceLazy(array, lazy, indexed) {
+    const newArray = [];
+    for (let index = 0; index < array.length; index++) {
+        const item = array[index];
+        const result = indexed ? lazy(item, index, array) : lazy(item);
+        if (result.hasMany === true) {
+            newArray.push(...result.next);
+        }
+        else if (result.hasNext) {
+            newArray.push(result.next);
+        }
+    }
+    return newArray;
+}

package/dist/es/utils/swap-in-place.js

@@ -0,0 +1,3 @@
+export function swapInPlace(data, i, j) {
+    [data[i], data[j]] = [data[j], data[i]];
+}

package/dist/es/utils/to-lazy-indexed.js

@@ -0,0 +1,3 @@
+export function toLazyIndexed(fn) {
+    return Object.assign(fn, { indexed: true });
+}

package/dist/es/utils/to-single.js

@@ -0,0 +1,4 @@
+export function toSingle(fn) {
+    fn.single = true;
+    return fn;
+}

package/dist/es/utils/types.js

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

package/dist/es/utils/with-precision.js

@@ -0,0 +1,19 @@
+const MAX_PRECISION = 15;
+export function withPrecision(roundingFn) {
+    return (value, precision) => {
+        if (precision === 0) {
+            return roundingFn(value);
+        }
+        if (!Number.isInteger(precision)) {
+            throw new TypeError(`precision must be an integer: ${precision}`);
+        }
+        if (precision > MAX_PRECISION || precision < -MAX_PRECISION) {
+            throw new RangeError(`precision must be between ${-MAX_PRECISION} and ${MAX_PRECISION}`);
+        }
+        if (Number.isNaN(value) || !Number.isFinite(value)) {
+            return roundingFn(value);
+        }
+        const multiplier = 10 ** precision;
+        return roundingFn(value * multiplier) / multiplier;
+    };
+}