@zajno/common 1.6.2 → 2.0.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zajno/common",
-  "version": "1.6.2",
+  "version": "2.0.0-beta.1",
   "description": "Zajno's re-usable utilities for JS/TS projects",
   "repository": {
     "type": "git",
@@ -13,40 +13,40 @@
   },
   "homepage": "https://github.com/Zajno/common-utils#readme",
   "scripts": {
-    "build": "rimraf ./lib && tsc",
+    "build": "tsc -P tsconfig.build.json",
+    "build:clean": "rimraf ./lib && yarn build",
     "build:w": "yarn build --watch",
     "publish:local": "yalc push --replace --update",
-    "prepare": "yarn build && yarn lint && yarn test",
+    "prepare": "yarn build:clean && yarn lint && yarn test",
     "postinstall": "yarn build",
     "lint": "eslint \"src/**/*.ts?(x)\"",
     "test": "yarn jest --clearCache && yarn jest"
   },
-  "dependencies": {
-    "rimraf": "^3"
-  },
+  "dependencies": {},
   "devDependencies": {
-    "@faker-js/faker": "^7.5.0",
-    "@types/jest": "^29.0.3",
-    "@types/node": "^16.11.59",
+    "@faker-js/faker": "^7.6.0",
+    "@types/jest": "^29.2.0",
+    "@types/node": "^18.11.7",
     "@zajno/eslint-config": "^2.2.0",
-    "eslint": "^8.23.1",
-    "fast-check": "^3.1.4",
-    "jest": "^29.0.3",
+    "eslint": "^8.26.0",
+    "fast-check": "^3.3.0",
+    "jest": "^29.2.2",
     "jest-extended": "^3.1.0",
-    "mobx": "^6.6.2",
-    "ts-jest": "^29.0.1",
+    "rimraf": "^3",
+    "ts-jest": "^29.0.3",
     "ts-node": "^10.9.1",
     "tslib": "^2.4.0",
-    "typescript": "^4.8.3"
+    "typescript": "^4.8.4"
   },
   "peerDependencies": {
-    "mobx": "^6.6",
+    "@types/node": "^18",
     "tslib": "^2.4",
     "typescript": "^4.8"
   },
   "files": [
     "src/*",
     "tsconfig.json",
+    "tsconfig.build.json",
     "LICENSE",
     "!.DS_Store",
     "!**/__tests__/**/*"

package/src/async/__tests__/timeout.test.ts

@@ -1,6 +1,6 @@
 
 import { timeoutPromise } from '../timeout';
-import { Event, oneTimeSubscription } from '../../event';
+import { Event, oneTimeSubscription } from '../../observing/event';
 
 describe('Timeouts', () => {
 

package/src/fields/update.ts

@@ -1,4 +1,4 @@
-import { safeCall } from '../functions';
+import { safeCall } from '../functions/safeCall';
 import { Comparator } from '../types';
 
 export namespace Fields {

package/src/{assert.ts → functions/assert.ts}

@@ -1,5 +1,5 @@
-import { Getter } from './types';
-import logger from './logger';
+import { Getter } from '../types';
+import logger from '../logger';
 
 export function assert(condition: boolean, error: Getter<string | Error>, objectToLog?: Getter<any>): asserts condition {
     if (condition) {

package/src/{disposer.ts → functions/disposer.ts}

@@ -1,4 +1,4 @@
-import logger from './logger';
+import logger from '../logger';
 
 export interface IDisposable {
     dispose(): void;

package/src/functions/safeCall.ts

@@ -0,0 +1,6 @@
+
+export function safeCall<T extends (...args: any) => any>(cb: T | undefined, ...args: Parameters<T>): ReturnType<T> | void {
+    if (cb) {
+        return cb.apply(null, args);
+    }
+}

package/src/{throttle.ts → functions/throttle.ts}

@@ -1,4 +1,4 @@
-import logger from './logger';
+import logger from '../logger';
 
 export class ThrottleAction<T = any> {
 

package/src/lazy/__tests__/lazy.test.ts

@@ -2,9 +2,7 @@ import { Lazy } from '../singleton';
 import { LazyPromise } from '../promise';
 import { setTimeoutAsync } from '../../async/timeout';
 
-import { LazyObservable, LazyPromiseObservable } from '../observable';
-import { reaction } from 'mobx';
-import { expectAnythingOrNothing } from '../../__tests__/helpers/expect';
+import '../../__tests__/helpers/expect';
 
 describe('Lazy', () => {
     it('simple', () => {
@@ -23,25 +21,6 @@ describe('Lazy', () => {
         expect(l.hasValue).toBeTrue();
         expect(l.value).toBe(VAL);
     });
-
-    it('observable', () => {
-        const createObj = () => ({ str: 'abc' });
-        const l = new LazyObservable(() => createObj());
-
-        const listener = jest.fn().mockImplementation();
-
-        const clean = reaction(() => l.value, listener, { fireImmediately: true });
-
-        expect(listener).toHaveBeenCalledWith(createObj(), expectAnythingOrNothing, expectAnythingOrNothing);
-
-        listener.mockClear();
-
-        l.reset();
-
-        expect(listener).toHaveBeenCalledWith(createObj(), expectAnythingOrNothing, expectAnythingOrNothing);
-
-        clean();
-    });
 });
 
 describe('LazyPromise', () => {
@@ -66,30 +45,4 @@ describe('LazyPromise', () => {
         expect(l.hasValue).toBeFalse();
     });
 
-    it('observable', async () => {
-        const VAL = 'abc';
-        const l = new LazyPromiseObservable(() => setTimeoutAsync(200).then(() => VAL));
-
-        expect(l.hasValue).toBeFalse();
-        expect(l.busy).toBeFalse();
-
-        expect(l.value).toBeUndefined();
-        expect(l.busy).toBeTrue();
-        expect(l.promise).not.toBeNull();
-
-        const listener = jest.fn().mockImplementation();
-        const clean = reaction(() => l.value, listener, { fireImmediately: true });
-
-        expect(listener).toHaveBeenCalledWith(undefined, expectAnythingOrNothing, expectAnythingOrNothing);
-
-        await expect(l.promise).resolves.not.toThrow();
-
-        expect(listener).toHaveBeenCalledWith(VAL, expectAnythingOrNothing, expectAnythingOrNothing);
-
-        expect(l.hasValue).toBeTrue();
-        expect(l.busy).toBeFalse();
-        expect(l.value).toBe(VAL);
-
-        clean();
-    });
 });

package/src/lazy/light.ts

@@ -1,4 +1,4 @@
-import type { IDisposable } from '../disposer';
+import type { IDisposable } from '../functions/disposer';
 
 export type LazyLight<T> = IDisposable & {
     readonly value: T;

package/src/lazy/promise.ts

@@ -1,4 +1,4 @@
-import type { IDisposable } from '../disposer';
+import type { IDisposable } from '../functions/disposer';
 
 export class LazyPromise<T> implements IDisposable {
 

package/src/lazy/singleton.ts

@@ -1,4 +1,4 @@
-import type { IDisposable } from '../disposer';
+import type { IDisposable } from '../functions/disposer';
 
 export class Lazy<T> implements IDisposable {
 

package/src/math/arrays.ts

@@ -259,3 +259,16 @@ export function arrayRepeat<T>(factory: Getter<T>, count = 1) {
     }
     return res;
 }
+
+export function chunkify<T>(array: T[], size: number): T[][] {
+    return array.reduce((res, item) => {
+        let arr = res[res.length - 1];
+        if (!arr || arr.length >= size) {
+            arr = [];
+            res.push(arr);
+        }
+
+        arr.push(item);
+        return res;
+    }, [] as T[][]);
+}

package/src/{event.ts → observing/event.ts}

@@ -1,7 +1,6 @@
-import type { Predicate } from './types';
-import './async/arrays';
-import { forEachAsync } from './async/arrays';
-import { ILogger, createLogger } from './logger';
+import type { Predicate } from '../types';
+import { forEachAsync } from '../async/arrays';
+import { ILogger, createLogger } from '../logger';
 
 export type EventHandler<T = any> = (data?: T) => void | Promise<void>;
 

package/src/{throttledEvent.ts → observing/throttledEvent.ts}

@@ -1,5 +1,5 @@
 import { Event } from './event';
-import { ThrottleAction } from './throttle';
+import { ThrottleAction } from '../functions/throttle';
 
 export class ThrottledEvent extends Event {
 

package/src/{timer.ts → observing/timer.ts}

@@ -1,4 +1,4 @@
-import { IDisposable } from './disposer';
+import { IDisposable } from '../functions/disposer';
 import { Event, EventHandler, IEvent } from './event';
 
 export class Timer implements IDisposable, IEvent<number> {

package/src/{services/storage → storage}/index.ts

@@ -1,4 +1,4 @@
-import IStorage, { IStorageSync } from '../../abstractions/services/storage';
+import IStorage, { IStorageSync } from '../abstractions/services/storage';
 
 export class StorageAsyncWrapper implements IStorage {
 

package/src/{services/storage → storage}/web/localStorage.ts

@@ -1,5 +1,5 @@
 import { KeyStorage, KeyStorageConverted, StorageAsyncWrapper } from '..';
-import IStorage, { IStorageSync } from '../../../abstractions/services/storage';
+import IStorage, { IStorageSync } from '../../abstractions/services/storage';
 import { WebStorage } from './webStorage';
 
 /* global window */

package/src/{services/storage → storage}/web/sessionStorage.ts

@@ -1,5 +1,5 @@
 import { KeyStorage, KeyStorageConverted, StorageAsyncWrapper } from '..';
-import IStorage, { IStorageSync } from '../../../abstractions/services/storage';
+import IStorage, { IStorageSync } from '../../abstractions/services/storage';
 import { WebStorage } from './webStorage';
 
 /* global window */

package/src/{services/storage → storage}/web/webStorage.ts

@@ -1,5 +1,5 @@
 
-import { IStorageSync } from '../../../abstractions/services/storage';
+import { IStorageSync } from '../../abstractions/services/storage';
 
 export abstract class WebStorage implements IStorageSync {
 

package/src/{__tests__ → structures/__tests__}/enumHelper.test.ts

@@ -1,4 +1,4 @@
-import EnumHelper, { EnumBitwiseHelper, EnumStringHelper } from '../enumHelper';
+import EnumHelper, { EnumBitwiseHelper, EnumStringHelper } from '../helpers/enum';
 
 enum Enum {
     Val1 = 1,

package/src/{__tests__ → structures/__tests__}/tempoCache.test.ts

@@ -1,5 +1,5 @@
 import { TempoCache } from '../tempoCache';
-import { setTimeoutAsync } from '../async/timeout';
+import { setTimeoutAsync } from '../../async/timeout';
 
 describe('TempoCache', () => {
     it('just works', async () => {

package/src/{nameHelper.ts → structures/helpers/name.ts}

@@ -1,11 +1,11 @@
 
-type DisplayName = { displayName: string };
-type SplittedName = {
+export type DisplayName = { displayName: string };
+export type SplittedName = {
     firstName: string,
     lastName: string,
 };
 
-type FullName = DisplayName & SplittedName;
+export type FullName = DisplayName & SplittedName;
 
 function splitDisplayName(name: Partial<DisplayName>): SplittedName {
     if (!name || !name.displayName) {
@@ -21,7 +21,7 @@ function splitDisplayName(name: Partial<DisplayName>): SplittedName {
     };
 }
 
-const NamesHelper = {
+export const NamesHelper = {
 
     split(name: Partial<DisplayName>): SplittedName { return splitDisplayName(name); },
     join(name: Partial<SplittedName>): DisplayName { return { displayName: `${name.firstName} ${name.lastName}` }; },

package/src/structures/linkedList.ts

@@ -0,0 +1,129 @@
+
+export interface ILinkedListItem<T> {
+    readonly value: T;
+    readonly next?: ILinkedListItem<T> | undefined;
+    readonly prev?: ILinkedListItem<T> | undefined;
+
+    readonly position: number;
+
+    readonly list: LinkedList<T>;
+}
+
+export interface ILinkedList<T> extends Iterable<ILinkedListItem<T>> {
+    readonly root: ILinkedListItem<T> | undefined;
+    readonly last: ILinkedListItem<T> | undefined;
+
+    readonly length: number;
+
+    add(value: T): ILinkedListItem<T>;
+    remove(item: ILinkedListItem<T>): void;
+    removeLast(): void;
+    removeFirst(): void;
+    clear(): void;
+}
+
+interface LinkedListItem<T> extends ILinkedListItem<T> {
+    next?: LinkedListItem<T>;
+    prev?: LinkedListItem<T>;
+
+    position: number;
+
+    list: LinkedList<T>;
+}
+
+export class LinkedList<T> implements ILinkedList<T> {
+
+    private _root: LinkedListItem<T> = null;
+    private _last: LinkedListItem<T> = null;
+
+    private _length = 0;
+
+    get root(): ILinkedListItem<T> { return this._root; }
+    get last(): ILinkedListItem<T> { return this._last; }
+    get length() { return this._length; }
+
+    *[Symbol.iterator]() {
+        let current = this._root;
+        while (current) {
+            yield current;
+            current = current.next;
+        }
+    }
+
+    add(value: T) {
+        const next: LinkedListItem<T> = {
+            value: value,
+            list: this,
+            position: null,
+        };
+
+        this._length++;
+
+        if (!this.root || !this.last) {
+            next.position = 0;
+            this._root = this._last = next;
+        } else {
+            next.prev = this._last;
+            this._last.next = next;
+            this._last = next;
+            next.position = this._length - 1;
+        }
+
+        return this.last;
+    }
+
+    remove(item: ILinkedListItem<T>) {
+        if (!item || item.list !== this) {
+            return;
+        }
+
+        const itemInternal = item as LinkedListItem<T>;
+        const { next, prev } = itemInternal;
+        let removed = false;
+
+        if (next && next.prev === item) {
+            next.prev = prev;
+
+            if (this._root === item) {
+                this._root = next;
+            }
+
+            removed = true;
+        }
+
+        if (prev && prev.next === item) {
+            prev.next = next;
+
+            if (this._last === item) {
+                this._last = prev;
+            }
+
+            removed = true;
+        }
+
+        itemInternal.prev = itemInternal.next = null;
+        itemInternal.list = undefined;
+
+        if (removed) {
+            this._length--;
+        }
+    }
+
+    removeLast(): void {
+        this.remove(this._last);
+    }
+
+    removeFirst(): void {
+        this.remove(this._root);
+    }
+
+    clear(): void {
+        for (const item of this) {
+            item.next = item.prev = undefined;
+            item.list = undefined;
+        }
+
+        this._root = this._last = null;
+        this._length = 0;
+    }
+}

package/src/{pool.ts → structures/pool.ts}

@@ -1,5 +1,5 @@
-import { safeCall } from 'functions';
-import type { IDisposable } from './disposer';
+import { safeCall } from '../functions/safeCall';
+import type { IDisposable } from '../functions/disposer';
 
 export class Pool<T> {
 

package/src/{queue → structures/queue}/__tests__/parallel.test.ts

@@ -1,7 +1,7 @@
 import 'jest-extended';
 import { ParallelQueue } from '../parallel';
-import { setTimeoutAsync } from '../../async/timeout';
-import { setMode } from '../../logger';
+import { setTimeoutAsync } from '../../../async/timeout';
+import { setMode } from '../../../logger';
 
 const createLoader = () => jest.fn(() => setTimeoutAsync(100));
 

package/src/{queue → structures/queue}/parallel.ts

@@ -1,5 +1,5 @@
-import { createLogger, ILogger } from '../logger';
-import { Event } from '../event';
+import { createLogger, ILogger } from '../../logger';
+import { Event } from '../../observing/event';
 
 export type QueueItem = () => void | Promise<void>;
 

package/src/types/comparator.ts

@@ -0,0 +1,6 @@
+
+export type Comparator<T, C = boolean> = (v1: T, v2: T) => C;
+
+export namespace Comparator {
+    export const Default: Comparator<any> = (a, b) => a === b;
+}

package/src/types/deep.ts

@@ -0,0 +1,18 @@
+
+type Primitive = number | string | Symbol | boolean | null | undefined | bigint;
+
+export type DeepReadonly<T> = T extends (Function | Primitive)
+    ? T
+    : (
+        T extends Object
+            ? { readonly [P in keyof T]: DeepReadonly<T[P]>; }
+            : T
+    );
+
+export type DeepPartial<T> = T extends (Function | Primitive)
+    ? T
+    : (
+        T extends Object
+            ? { [P in keyof T]?: DeepPartial<T[P]>; }
+            : T
+    );

package/src/types/functions.ts

@@ -0,0 +1,8 @@
+
+export type PropertiesOf<T> = Exclude<{
+    [K in keyof T]: T[K] extends Function ? never : K
+}[keyof T], undefined>;
+
+export type RemoveFunctionFields<T> = {
+    readonly [P in PropertiesOf<T>]: T[P];
+};

package/src/types/getter.ts

@@ -0,0 +1,14 @@
+
+export type Getter<T> = (() => T) | T | null;
+
+export namespace Getter {
+    export function getValue<T>(getter: Getter<T>): T {
+        if (getter == null) {
+            return undefined;
+        }
+        if (typeof getter === 'function') {
+            return (getter as () => T)();
+        }
+        return getter;
+    }
+}

package/src/types/index.ts

@@ -0,0 +1,9 @@
+export * from './deep';
+export * from './getter';
+export * from './comparator';
+
+export type Predicate<T> = (value: T) => boolean;
+
+export type TypedKeys<T extends Object, K> = {
+    [P in keyof T]: T[P] extends K ? P : never
+}[keyof T];

package/src/validation/ValidationErrors.ts

@@ -1,4 +1,4 @@
-import EnumHelper from '../enumHelper';
+import EnumHelper from '../structures/helpers/enum';
 
 export enum ValidationErrors {
     None = 0,

package/src/web/breakpoints/index.ts

@@ -0,0 +1,3 @@
+
+export { BreakpointData, ICurrentBreakpointInfo } from './types';
+export { BreakpointsManager } from './manager';

package/src/web/breakpoints/manager.ts

@@ -0,0 +1,65 @@
+import { BreakpointData, ICurrentBreakpointInfo } from './types';
+import { Event } from '../../observing/event';
+import { createLogger } from '../../logger';
+import { calcRem } from './rem';
+
+const logger = createLogger('[Breakpoints]');
+
+export class BreakpointsManager<TType extends string = string, TMeta = any> implements ICurrentBreakpointInfo<TType, TMeta> {
+
+    private readonly _remChanged = new Event<number>();
+    private readonly _breakpointChanged = new Event<BreakpointData<TType, TMeta>>();
+
+    private readonly _list: BreakpointData<TType, TMeta>[] = [];
+
+    private readonly _state = {
+        width: 0,
+        height: 0,
+        currentBreakpoint: null as BreakpointData<TType, TMeta>,
+        currentRem: 0.0,
+    };
+
+    registerBreakpoint(bp: BreakpointData<TType, TMeta>) {
+        const existing = this._list.findIndex(b => b.id === bp.id);
+        if (existing >= 0) {
+            this._list[existing] = bp;
+        } else {
+            this._list.push(bp);
+            this._list.sort((b1, b2) => b1.id - b2.id);
+        }
+    }
+
+    get breakpoint() { return this._state.currentBreakpoint; }
+
+    get rem() { return this._state.currentRem; }
+
+    get width() { return this._state.width; }
+    get height() { return this._state.height; }
+
+    get breakpointChanged() { return this._breakpointChanged; }
+    get remChanged() { return this._remChanged; }
+
+    resize(width: number, height: number) {
+        let bp = this._list.find(b => window.matchMedia(b.mediaQuery).matches);
+        if (!bp) {
+            bp = this._list[0];
+        }
+
+        this._state.width = width;
+        this._state.height = height;
+
+        const rem = calcRem(width, height, bp);
+
+        logger.log('Current breakpoint:', `[${width}x${height}]`, bp, '; rem =', rem);
+
+        if (!this._state.currentBreakpoint || this._state.currentBreakpoint.id !== bp.id) {
+            this._state.currentBreakpoint = bp;
+            this._breakpointChanged.trigger(bp);
+        }
+
+        if (this._state.currentRem !== rem) {
+            this._state.currentRem = rem;
+            this._remChanged.trigger(rem);
+        }
+    }
+}

package/src/web/breakpoints/rem.ts

@@ -0,0 +1,24 @@
+import { BreakpointData } from './types';
+
+export function calcRem(width: number, height: number, breakpoint: BreakpointData) {
+    if (!breakpoint.width && !breakpoint.height) {
+        return 1;
+    }
+
+    if (!breakpoint.height) {
+        return width / breakpoint.width;
+    }
+
+    if (!breakpoint.width) {
+        return height / breakpoint.height;
+    }
+
+    const ab = breakpoint.width / breakpoint.height;
+    const avp = width / height;
+
+    const rem = ab < avp
+        ? (height / breakpoint.height)
+        : (width / breakpoint.width);
+
+    return rem;
+}