@zajno/common 1.6.3 → 2.0.0-beta.2

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/{abstractions/services/storage.ts → storage/abstractions.ts}

@@ -1,5 +1,5 @@
 
-export default interface IStorage {
+export interface IStorage {
     getValue(key: string): Promise<string>;
     setValue(key: string, value: string): Promise<void>;
 
@@ -14,3 +14,5 @@ export interface IStorageSync {
     removeValue(key: string): boolean;
     hasValue(key: string): boolean;
 }
+
+export default IStorage;

package/src/storage/asyncWrapper.ts

@@ -0,0 +1,24 @@
+import { IStorage, IStorageSync } from './abstractions';
+
+export class StorageAsyncWrapper implements IStorage {
+
+    constructor(readonly webStorage: IStorageSync) { }
+
+    getValue(key: string) {
+        return Promise.resolve(this.webStorage.getValue(key));
+    }
+
+    setValue(key: string, value: string) {
+        this.webStorage.setValue(key, value);
+        return Promise.resolve();
+    }
+
+    hasValue(key: string) {
+        return Promise.resolve(this.webStorage.hasValue(key));
+    }
+
+    remove(key: string) {
+        this.webStorage.removeValue(key);
+        return Promise.resolve();
+    }
+}

package/src/storage/index.ts

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

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

@@ -1,27 +1,4 @@
-import IStorage, { IStorageSync } from '../../abstractions/services/storage';
-
-export class StorageAsyncWrapper implements IStorage {
-
-    constructor(readonly webStorage: IStorageSync) { }
-
-    getValue(key: string) {
-        return Promise.resolve(this.webStorage.getValue(key));
-    }
-
-    setValue(key: string, value: string) {
-        this.webStorage.setValue(key, value);
-        return Promise.resolve();
-    }
-
-    hasValue(key: string) {
-        return Promise.resolve(this.webStorage.hasValue(key));
-    }
-
-    remove(key: string) {
-        this.webStorage.removeValue(key);
-        return Promise.resolve();
-    }
-}
+import { IStorageSync } from './abstractions';
 
 export class KeyStorage {
     constructor(readonly storage: IStorageSync, readonly key: string) { }

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}/__tests__/tasks.test.ts

@@ -1,6 +1,6 @@
 import { TasksQueue } from '../tasks';
-import { setTimeoutAsync } from '../../async/timeout';
-import { safeCall } from '../../functions';
+import { setTimeoutAsync } from '../../../async/timeout';
+import { safeCall } from '../../../functions/safeCall';
 import 'jest-extended';
 
 describe('TasksQueue', () => {

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/{queue → structures/queue}/tasks.ts

@@ -1,4 +1,4 @@
-import type { ILogger } from '../logger';
+import type { ILogger } from '../../logger';
 
 type Factory<T> = () => Promise<T>;
 

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/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+    "extends": "./tsconfig.json",
+    "include": [
+        "./src"
+    ],
+    "exclude": [
+        "node_modules",
+        "**/__tests__/**"
+    ],
+  }

package/tsconfig.json

@@ -27,7 +27,6 @@
   ],
   "exclude": [
     "node_modules",
-    "**/__tests__/**"
   ],
   "references": []
 }