@dungarees/core 0.11.0

package/type-util.test.js

@@ -0,0 +1,135 @@
+import { assert } from 'tsafe';
+import { test } from 'vitest';
+test('Split<PATH, DELIMITER>', () => {
+    assert();
+    assert();
+    assert();
+    assert();
+    assert();
+});
+test('SplitObjectPath<PATH>', () => {
+    assert();
+    assert();
+    assert();
+    assert();
+});
+test('SplitFilePath<PATH>', () => {
+    assert();
+    assert();
+    assert();
+    assert();
+});
+test('StringLiteral<LITERAL>', () => {
+    const literal = 'asd';
+    assert();
+    // @ts-expect-error it has to be a literal
+    const nonLiteral = 'asd';
+    assert();
+});
+test('ObjectWithStringLiteralKey<KEY, VALUE>', () => {
+    const obj = {
+        a: 1,
+    };
+    assert();
+    // @ts-expect-error it has to be a literal
+    const nonLiteral = {
+        a: 1,
+    };
+    assert();
+});
+test('JsonType', () => {
+    const json = {
+        a: 1,
+        b: '2',
+        c: true,
+        d: null,
+        e: [1, '2', true, null, [1, '2', true, null]],
+    };
+    assert();
+    // @ts-expect-error it cannot be a function
+    const nonJson = {
+        f: () => { },
+    };
+    assert();
+});
+test('TokenNonEmptyString<TOKEN>', () => {
+    const token = 'a';
+    assert();
+    // @ts-expect-error it cannot be empty
+    const nonToken = '';
+    assert();
+});
+test('Guard<TYPE>', () => {
+    const guard = (arg) => arg === 1;
+    assert();
+    // @ts-expect-error it has to be a guard
+    const nonGuard = (arg) => arg === 1;
+    assert();
+});
+test('GetGuarded<GUARD>', () => {
+    const guard = (arg) => arg === 1;
+    assert();
+});
+test('EntryTuples', () => {
+    assert();
+    assert();
+    assert();
+    assert();
+});
+test('FilterRecord<RECORD, TYPE>', () => {
+    // TODO remove the keys as well
+    assert();
+});
+test('GetAllPaths<OBJECT>', () => {
+    assert();
+});
+test('GetValuesByPath<OBJECT, PATH>', () => {
+    assert();
+});
+test('JoinArray<STRINGS, DELIMITER>', () => {
+    assert();
+    assert();
+});
+test('FromCamelCase<STRING>', () => {
+    assert();
+    assert();
+    assert();
+});
+test('ToCamelCase<STRING[]>', () => {
+    assert();
+    assert();
+});
+test('FromKebabCase<STRING>', () => {
+    assert();
+    assert();
+    assert();
+});
+test('ToKebabCase<STRING[]>', () => {
+    assert();
+    assert();
+});
+test('FromSnakeCase<STRING>', () => {
+    assert();
+    assert();
+    assert();
+});
+test('ToSnakeCase<STRING[]>', () => {
+    assert();
+    assert();
+});
+test('Mutable<TYPE>', () => {
+    assert();
+    assert();
+});
+test('PartialBesides<OBJECT, KEYS>', () => {
+    assert();
+});
+test('DeepPartial<T> - single level', () => {
+    assert();
+});
+test('DeepPartial<T> - nested props', () => {
+    assert();
+});
+test('SyncFunctionToAsync<FUNC>', () => {
+    assert();
+});

package/url.d.ts

@@ -0,0 +1,13 @@
+export type UrlConfig = {
+    protocol: string;
+    hostname: string;
+    pathname?: string;
+    port?: number;
+    search?: UrlSearchConfig | undefined;
+    hash?: string;
+};
+export type UrlSearchConfig = Record<string, number | string | boolean>;
+export declare const stringifyUrl: (config: UrlConfig) => string;
+export declare const parseUrl: (url: `${string}://${string}`) => UrlConfig;
+export type Split<STRING, CHARACTER extends string> = STRING extends `${infer S1}${CHARACTER}${infer S2}` ? [S1, S2] : never;
+export type Url = string;

package/url.js

@@ -0,0 +1,24 @@
+const DEFAULT_PORT = 80;
+export const stringifyUrl = (config) => {
+    const { protocol, hostname, search = {}, ...rest } = config;
+    const url = new URL(`${protocol}://${hostname}`);
+    let key;
+    for (key in rest) {
+        url[key] = String(rest[key]);
+    }
+    for (const [k, v] of Object.entries(search)) {
+        url.searchParams.append(k, String(v));
+    }
+    return url.toString();
+};
+export const parseUrl = (url) => {
+    const { protocol, hostname, pathname, port, searchParams, hash } = new URL(url);
+    return {
+        protocol: protocol.at(-1) === ':' ? protocol.slice(0, -1) : protocol,
+        hostname,
+        pathname,
+        port: port?.length > 0 ? Number(port) : DEFAULT_PORT,
+        hash: hash[0] === '#' ? hash.slice(1) : hash,
+        search: Object.fromEntries(searchParams.entries()),
+    };
+};

package/url.test.d.ts

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

package/url.test.js

@@ -0,0 +1,48 @@
+import { parseUrl, stringifyUrl } from './url.js';
+import { expect, test } from 'vitest';
+test('stringify full url', () => {
+    expect(stringifyUrl({
+        protocol: 'https',
+        hostname: 'localhost',
+        pathname: '/path',
+        port: 8080,
+        search: {
+            a: '1',
+            b: '2',
+        },
+        hash: 'hash',
+    })).toBe('https://localhost:8080/path?a=1&b=2#hash');
+});
+test('stringify partial url', () => {
+    expect(stringifyUrl({
+        protocol: 'https',
+        hostname: 'localhost',
+    })).toBe('https://localhost/');
+});
+test('parse full url', () => {
+    expect(parseUrl('https://localhost:8080/path?a=1&b=2#hash')).toEqual({
+        protocol: 'https',
+        hostname: 'localhost',
+        pathname: '/path',
+        port: 8080,
+        search: {
+            a: '1',
+            b: '2',
+        },
+        hash: 'hash',
+    });
+});
+test('parse full url', () => {
+    expect(parseUrl('https://localhost/')).toEqual({
+        protocol: 'https',
+        hostname: 'localhost',
+        pathname: '/',
+        port: 80,
+        search: {},
+        hash: '',
+    });
+});
+test('Url type', () => {
+    const url = 'https://host:8080/path/subpath/?a=1&b=2#hash';
+    expect(url).toBe(url);
+});

package/util.d.ts

@@ -0,0 +1,53 @@
+import type { Guard, JsonType } from './type-util.ts';
+import type { Call, Fn } from 'hotscript';
+export declare const typeKey: unique symbol;
+export declare const makeObjectFromStringLiteral: <KEY, VALUE>(key: StringLiteral<KEY>, value: VALUE) => ObjectWithStringLiteralKey<KEY, VALUE>;
+export declare const split: <const STRING extends string, const DELIMITER extends string>(str: STRING, delimiter: DELIMITER) => Split<STRING, DELIMITER>;
+export declare const join: <const KEYS extends string[], const DELIMITER extends string>(keys: KEYS, delimiter: DELIMITER) => JoinArray<KEYS, DELIMITER>;
+export declare const capitalize: <const STRING extends string>(str: STRING) => Capitalize<STRING>;
+export declare const pluralize: (str: string, value: number, prefix?: boolean) => string;
+export declare const toCamelCase: <const SEGMENTS extends readonly string[]>(segments: SEGMENTS) => ToCamelCase<SEGMENTS>;
+export declare const kebabCase2camelCase: <const KEBAB_CASE extends string>(kebabCase: KEBAB_CASE) => ToCamelCase<FromKebabCase<KEBAB_CASE>>;
+export declare const camelCase2kebabCase: <const CAMEL_CASE extends string>(camelCase: CAMEL_CASE) => ToKebabCase<FromCamelCase<CAMEL_CASE>>;
+export declare const isDeepEqual: (a: any, b: any) => boolean;
+export declare const deepEqualPartial: (actual: any, expected: any) => boolean;
+export declare const findByPattern: <MATCH extends JsonType, const PATTERNS extends readonly FindByPatterns[]>(patterns: PATTERNS, itemToMatch: MATCH) => GetValueFromPatternList<PATTERNS> | undefined;
+export declare const optionalPatternToList: <const VALUE>(value: VALUE) => OptionalPatternToList<VALUE>;
+export type FindByPatterns = FindByPattern | FindByPartialPattern | FindByDefault;
+export type FindByPattern<VALUE = any, PATTERN extends JsonType = JsonType> = {
+    readonly value: VALUE;
+    readonly pattern: PATTERN;
+};
+export type FindByPartialPattern<VALUE = any, PATTERN extends JsonType = JsonType> = {
+    readonly value: VALUE;
+    readonly patternPartial: Partial<PATTERN>;
+};
+export type FindByDefault<VALUE = any> = {
+    readonly value: VALUE;
+};
+export type OptionalPatternList<VALUE, PATTERN extends JsonType> = VALUE | Array<FindByPattern<VALUE, PATTERN> | FindByPartialPattern<VALUE, PATTERN> | FindByDefault<VALUE>>;
+export type GetValueFromPatternList<PATTERNS extends readonly FindByPatterns[]> = PATTERNS[number]['value'];
+export type OptionalPatternToList<VALUE> = VALUE extends readonly FindByPatterns[] ? VALUE : readonly [FindByDefault<VALUE>];
+export declare const isDefined: <T>(value: T) => value is NonNullable<T>;
+export declare const assertDefined: <T>(value: T, messageOption?: ErrorMessage<T>) => NonNullable<T>;
+export declare const assertTypeByGuard: <T, V>({ value, guard, message, }: AssertTypeByGuardArg<T, V>) => V & T;
+type AssertPredicateArg<T> = {
+    value: T;
+    predicate: (value: T) => boolean;
+    message: ErrorMessage<T>;
+};
+export declare const assertPredicate: <T>({ value, predicate, message, }: AssertPredicateArg<T>) => T;
+export declare const assertImpossible: (message: string) => never;
+type ErrorMessage<T> = string | ((value: T) => string);
+type AssertTypeByGuardArg<T, V> = {
+    value: V;
+    guard: Guard<T>;
+    message: ErrorMessage<V>;
+};
+export declare const unPrototypeProperties: <const T extends Record<string, any>, const KEYS extends keyof T>(obj: T, keys: KEYS[]) => Pick<T, KEYS>;
+type MapConstResult<ARRAY extends readonly any[], F extends Fn> = {
+    readonly [K in keyof ARRAY]: Call<F, ARRAY[K]>;
+};
+export declare const mapConst: <const ARRAY extends readonly any[]>(array: ARRAY) => <F extends Fn>(transformer: (value: ARRAY[number]) => unknown) => MapConstResult<ARRAY, F>;
+export declare const objectFromConstEntries: <const ENTRIES extends readonly (readonly [string, any])[]>(entries: ENTRIES) => { [K in ENTRIES[number] as K[0]]: K[1]; };
+export {};

package/util.js

@@ -0,0 +1,236 @@
+export const typeKey = Symbol('type');
+export const makeObjectFromStringLiteral = (key, value) => {
+    // We have to cast the type because [key] is always considered as string
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return { [key]: value };
+};
+export const split = (str, delimiter) => str.split(delimiter);
+export const join = (keys, delimiter) => keys.join(delimiter);
+export const capitalize = (str) => {
+    return `${str[0]?.toUpperCase()}${str.slice(1)}`;
+};
+export const pluralize = (str, value, prefix = false) => {
+    return `${prefix ? value + ' ' : ''}${str}${Math.abs(value) === 1 ? '' : 's'}`;
+};
+const fromKebabCase = (kebabCase) => {
+    return split(kebabCase, '-');
+};
+const toKebabCase = (segments) => {
+    const mutableSegments = segments;
+    return join(mutableSegments, '-');
+};
+const fromCamelCase = (input) => {
+    const segments = input.match(/[A-Z]?[a-z]+|[0-9]+/g) ?? [];
+    return segments.map((s) => s.toLowerCase());
+};
+export const toCamelCase = (segments) => {
+    return segments.reduce((acc, segment, index) => {
+        if (index === 0) {
+            return segment;
+        }
+        if (segment.length === 0) {
+            return acc;
+        }
+        return `${acc}${capitalize(segment)}`;
+    }, '');
+};
+export const kebabCase2camelCase = (kebabCase) => toCamelCase(fromKebabCase(kebabCase));
+export const camelCase2kebabCase = (camelCase) => toKebabCase(fromCamelCase(camelCase));
+export const isDeepEqual = (a, b) => {
+    // in order to support circular references we have to keep track of visited objects.
+    // for that reason we have to create new function for each invocation.
+    const visited = new WeakMap();
+    // eslint-disable-next-line complexity
+    const inner = (a, b) => {
+        // in case strict equality - there is nothing to check anymore.
+        if (a === b) {
+            return true;
+        }
+        // in case any of values is not an object, there is nothing to do, except to check strict equality.
+        if (typeof a !== 'object' || typeof b !== 'object' || !a || !b) {
+            // looks weird, but it is most efficient way to test NaN.
+            // otherwise we have to involve Number.isNaN, which causes context switch and therefore is slower.
+            // eslint-disable-next-line no-self-compare
+            return a !== a && b !== b;
+        }
+        // if constructors are different, objects are definitely not equal.
+        if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) {
+            return false;
+        }
+        const { constructor } = a;
+        if (constructor === Date) {
+            return a.getTime() === b.getTime();
+        }
+        if (constructor === RegExp) {
+            return a.source === b.source && a.flags === b.flags;
+        }
+        if (constructor === Set) {
+            if (a.size !== b.size) {
+                return false;
+            }
+            for (const value of a) {
+                if (!b.has(value)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (constructor === ArrayBuffer) {
+            a = new DataView(a);
+            b = new DataView(b);
+        }
+        if (constructor === DataView || ArrayBuffer.isView(a)) {
+            // this is a TypedArray.
+            if (constructor !== DataView) {
+                a = new DataView(a.buffer);
+                b = new DataView(b.buffer);
+            }
+            if (a.byteLength !== b.byteLength)
+                return false;
+            for (let i = a.byteLength; i-- !== 0;) {
+                if (a.getUint8(i) !== b.getUint8(i)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        // Check circular references
+        if (visited.has(a) && visited.get(a) === b) {
+            return true;
+        }
+        visited.set(a, b);
+        if (constructor === Array) {
+            if (a.length !== b.length) {
+                return false;
+            }
+            for (let i = a.length; i-- !== 0;) {
+                if (!inner(a[i], b[i])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (constructor === Map) {
+            if (a.size !== b.size) {
+                return false;
+            }
+            for (const entry of a) {
+                if (!b.has(entry[0]) || !inner(entry[1], b.get(entry[0]))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        // at this point, we've handled all possible data containers and we can compare objects as plain.
+        if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === 'function' && typeof b.valueOf === 'function') {
+            return a.valueOf() === b.valueOf();
+        }
+        if (a.toString !== Object.prototype.toString && typeof a.toString === 'function' && typeof b.toString === 'function') {
+            return a.toString() === b.toString();
+        }
+        const aKeys = Object.keys(a);
+        let key;
+        for (let l = aKeys.length; l-- !== 0;) {
+            key = aKeys[l];
+            if (!Object.hasOwn(b, key) || !inner(a[key], b[key])) {
+                return false;
+            }
+        }
+        return Object.keys(b).length === aKeys.length;
+    };
+    return inner(a, b);
+};
+export const deepEqualPartial = (actual, expected) => {
+    if (actual === undefined || actual === null) {
+        return true;
+    }
+    const isObject = (input) => typeof input === 'object';
+    if (!isObject(expected)) {
+        return expected === actual;
+    }
+    if (!isObject(actual)) {
+        return false;
+    }
+    return Object.keys(actual).every((key) => {
+        const val = actual[key];
+        if (val instanceof Object) {
+            return deepEqualPartial(expected[key], val);
+        }
+        return actual[key] === expected[key];
+    });
+};
+export const findByPattern = (patterns, itemToMatch) => patterns
+    .map(toPatternResolver)
+    .sort((a, b) => a.priority - b.priority)
+    .find(({ match }) => match(itemToMatch))?.value;
+export const optionalPatternToList = (value) => {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return [{ value }];
+};
+const createPatternResolver = ({ pattern, value }) => ({
+    value,
+    match: (itemToMatch) => isDeepEqual(pattern, itemToMatch),
+    priority: 0,
+});
+createPatternResolver.is = (pattern) => 'pattern' in pattern;
+const createPatternPartialResolver = ({ patternPartial, value, }) => ({
+    value,
+    match: (itemToMatch) => deepEqualPartial(patternPartial, itemToMatch),
+    priority: 1,
+});
+createPatternPartialResolver.is = (pattern) => 'patternPartial' in pattern;
+const createDefaultResolver = ({ value }) => ({
+    value,
+    match: () => true,
+    priority: 2,
+});
+const toPatternResolver = (pattern) => {
+    if (createPatternResolver.is(pattern)) {
+        return createPatternResolver(pattern);
+    }
+    if (createPatternPartialResolver.is(pattern)) {
+        return createPatternPartialResolver(pattern);
+    }
+    return createDefaultResolver(pattern);
+};
+export const isDefined = (value) => {
+    return value !== null && value !== undefined;
+};
+export const assertDefined = (value, messageOption = 'Undefined value') => {
+    if (value === null || value === undefined) {
+        throw new Error(getErrorMessage(messageOption, value));
+    }
+    return value;
+};
+export const assertTypeByGuard = ({ value, guard, message, }) => {
+    if (!guard(value)) {
+        throw new Error(getErrorMessage(message, value));
+    }
+    return value;
+};
+export const assertPredicate = ({ value, predicate, message, }) => {
+    if (!predicate(value)) {
+        throw new Error(getErrorMessage(message, value));
+    }
+    return value;
+};
+export const assertImpossible = (message) => {
+    throw new Error(message);
+};
+const getErrorMessage = (message, value) => typeof message === 'function' ? message(value) : message;
+export const unPrototypeProperties = (obj, keys) => {
+    const propertyEntries = keys.map((key) => {
+        const value = isFunction(obj[key]) ? (...args) => obj[key](...args) : obj[key];
+        return [key, value];
+    });
+    return Object.fromEntries(propertyEntries);
+};
+const isFunction = (value) => value instanceof Function;
+export const mapConst = (array) => (transformer) => {
+    return array.map((item) => transformer(item));
+};
+export const objectFromConstEntries = (entries) => {
+    return Object.fromEntries(entries);
+};

package/util.test.d.ts

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