@searchspring/snap-url-manager 0.20.0

package/dist/esm/UrlManager/UrlManager.js

@@ -0,0 +1,256 @@
+import Immutable from 'seamless-immutable';
+class WatcherPool {
+    constructor() {
+        this.callbacks = [];
+        // nothing to do here
+    }
+    subscribe(cb) {
+        this.callbacks.push(cb);
+        return () => (this.callbacks = this.callbacks.filter((_cb) => _cb != cb));
+    }
+    notify() {
+        this.callbacks.forEach((cb) => cb());
+    }
+}
+export class UrlManager {
+    constructor(translator, linker, globalState, localState, watcherPool, omissions = [], detached) {
+        this.linker = linker;
+        this.omissions = omissions;
+        this.detached = detached;
+        this.urlState = Immutable({});
+        this.globalState = Immutable({});
+        this.localState = Immutable({});
+        this.mergedState = Immutable({});
+        this.localState = Immutable(localState || {});
+        this.globalState = Immutable(globalState || {});
+        this.translator = translator;
+        if (watcherPool) {
+            this.watcherPool = watcherPool;
+        }
+        else {
+            this.watcherPool = new WatcherPool();
+            if (this.translator.bindExternalEvents instanceof Function) {
+                this.translator.bindExternalEvents(() => this.watcherPool.notify());
+            }
+        }
+        this.subscribe(() => {
+            this.refresh();
+        });
+        this.refresh();
+    }
+    without(obj, fullPath, values) {
+        // TODO: refactor - find way to remove updateNode function
+        const path = fullPath.slice(0, -1);
+        const lastKey = fullPath[fullPath.length - 1];
+        if (!path.length) {
+            if (!values?.length) {
+                return obj.without(lastKey);
+            }
+            return updateNode(lastKey, obj);
+        }
+        if (!obj.getIn(path)) {
+            return obj;
+        }
+        return obj.updateIn(path, (node) => {
+            return updateNode(lastKey, node);
+        });
+        function updateNode(key, node) {
+            if (node[lastKey] === undefined) {
+                return node;
+            }
+            if (node[lastKey] instanceof Array) {
+                if (!values || !values.length) {
+                    return node.without(lastKey);
+                }
+                return node.set(lastKey, node[lastKey].filter((value) => {
+                    return !values.some((removeValue) => {
+                        return compareObjects(value, removeValue);
+                    });
+                }));
+            }
+            if (typeof node == 'object') {
+                return node.without(lastKey);
+            }
+            return node;
+        }
+    }
+    getTranslatorUrl() {
+        if (this.detached) {
+            return this.detached.url;
+        }
+        return this.translator.getCurrentUrl();
+    }
+    refresh() {
+        this.prevState = this.mergedState;
+        this.urlState = this.omissions.reduce((state, om) => {
+            return this.without(state, om.path, om.values);
+        }, Immutable(this.translator.deserialize(this.getTranslatorUrl())));
+        this.mergedState = this.globalState.merge(this.urlState, {
+            deep: true,
+            merger: arrayConcatMerger,
+        });
+        this.mergedState = this.mergedState.merge(this.localState, {
+            deep: true,
+            merger: arrayConcatMerger,
+        });
+    }
+    get state() {
+        return this.mergedState;
+    }
+    unpackPathAndState(stateOrPath, _state) {
+        const path = stateOrPath instanceof Array ? stateOrPath : typeof stateOrPath == 'string' ? stateOrPath.split('.') : [];
+        const state = !(stateOrPath instanceof Array) && typeof stateOrPath == 'object' ? stateOrPath : _state === undefined ? {} : _state;
+        return { path, state };
+    }
+    set(...args) {
+        const { path, state } = this.unpackPathAndState(args[0], args[1]);
+        const newState = path.length ? this.localState.setIn(path, removeArrayDuplicates(state)) : removeArrayDuplicates(state);
+        const omissions = removeArrayDuplicates(this.omissions.concat(path.length ? { path } : Object.keys(this.urlState).map((key) => ({ path: [key] }))));
+        return new UrlManager(this.translator, this.linker, this.globalState, newState, this.watcherPool, omissions, this.detached);
+    }
+    merge(...args) {
+        const { path, state } = this.unpackPathAndState(args[0], args[1]);
+        const newState = path.length
+            ? this.localState.updateIn(path, (oldState) => {
+                if (oldState instanceof Array) {
+                    const newValues = Array.isArray(state) ? state : [state];
+                    return removeArrayDuplicates(oldState.concat(newValues));
+                }
+                else if (typeof oldState == 'object') {
+                    if (Array.isArray(state)) {
+                        return state.length ? removeArrayDuplicates([oldState].concat(state)) : oldState;
+                    }
+                    else {
+                        return oldState.merge(state, { deep: true, merger: arrayConcatMerger });
+                    }
+                }
+                else if (typeof oldState != 'undefined') {
+                    // not an object or array
+                    const newValues = (Array.isArray(state) ? state : [state]).filter((value) => !compareObjects(value, oldState));
+                    return newValues.length ? removeArrayDuplicates([oldState].concat(newValues)) : oldState;
+                }
+                else if (typeof oldState == 'undefined') {
+                    const urlState = this.urlState.getIn(path);
+                    if (urlState instanceof Array && !Array.isArray(state)) {
+                        return [state];
+                    }
+                }
+                return state;
+            })
+            : this.localState.merge(state, { deep: true, merger: arrayConcatMerger });
+        return new UrlManager(this.translator, this.linker, this.globalState, newState, this.watcherPool, this.omissions, this.detached);
+    }
+    remove(_path, values) {
+        const { path } = this.unpackPathAndState(_path, {});
+        values = typeof values != 'undefined' ? (values instanceof Array ? values : [values]) : [];
+        const without = this.without(this.localState, path, values);
+        const omissions = removeArrayDuplicates(this.omissions.concat({ path, values: values }));
+        return new UrlManager(this.translator, this.linker, this.globalState, without, this.watcherPool, omissions, this.detached);
+    }
+    reset() {
+        return new UrlManager(this.translator, this.linker, this.globalState, {}, this.watcherPool, Object.keys(this.urlState).map((k) => ({ path: [k] })), this.detached);
+    }
+    withConfig(config) {
+        if (config instanceof Function) {
+            config = config(this.translator.getConfig());
+        }
+        return new UrlManager(new (Object.getPrototypeOf(this.translator).constructor)(config), this.linker, this.globalState, this.localState, this.watcherPool, this.omissions, this.detached);
+    }
+    withGlobals(globals) {
+        return new UrlManager(this.translator, this.linker, globals, this.localState, this.watcherPool, this.omissions, this.detached);
+    }
+    getTranslatorConfig() {
+        return this.translator.getConfig();
+    }
+    get href() {
+        return this.translator.serialize(this.state);
+    }
+    go(config) {
+        if (this.detached) {
+            this.detached.url = this.href;
+        }
+        else {
+            this.translator.go(this.href, config);
+        }
+        this.watcherPool.notify();
+    }
+    detach(reset = false) {
+        return new UrlManager(this.translator, this.linker, this.globalState, this.localState, new WatcherPool(), this.omissions, {
+            url: reset ? '' : this.getTranslatorUrl(),
+        });
+    }
+    get link() {
+        if (!this.linker) {
+            return {};
+        }
+        return this.linker(this);
+    }
+    subscribe(cb) {
+        return this.watcherPool.subscribe(() => {
+            const prevState = this.prevState;
+            const state = this.mergedState;
+            cb(prevState, state);
+        });
+    }
+}
+function removeArrayDuplicates(array) {
+    if (Array.isArray(array) && array.length) {
+        return array.reduce((accu, item) => {
+            if (!accu.some((keep) => compareObjects(keep, item))) {
+                accu.push(item);
+            }
+            return accu;
+        }, [array[0]]);
+    }
+    return array;
+}
+function arrayConcatMerger(current, other) {
+    if (current instanceof Array && other instanceof Array) {
+        return removeArrayDuplicates([...current, ...other]);
+    }
+}
+function compareObjects(obj1, obj2) {
+    if (!obj1 && !obj2) {
+        return true;
+    }
+    else if ((!obj1 && obj2) || (obj1 && !obj2)) {
+        return false;
+    }
+    const primitives = ['string', 'number', 'boolean', 'undefined'];
+    const typeA = typeof obj1;
+    const typeB = typeof obj2;
+    if (typeA !== typeB)
+        return false;
+    if (primitives.includes(typeA))
+        return obj1 === obj2;
+    const isArrayA = Array.isArray(obj1);
+    const isArrayB = Array.isArray(obj2);
+    if (isArrayA !== isArrayB) {
+        return false;
+    }
+    if (isArrayA) {
+        // compare arrays
+        if (obj1.length != obj2.length)
+            return false;
+        for (let i = 0; i < obj1.length; i++) {
+            if (!compareObjects(obj1[i], obj2[i])) {
+                return false;
+            }
+        }
+    }
+    else {
+        // compare object keys
+        if (!compareObjects(Object.keys(obj1).sort(), Object.keys(obj2).sort())) {
+            return false;
+        }
+        // compare object values
+        let result = true;
+        Object.keys(obj1).forEach((key) => {
+            if (!compareObjects(obj1[key], obj2[key])) {
+                result = false;
+            }
+        });
+        return result;
+    }
+    return true;
+}

package/dist/esm/UrlManager/typecheck.d.ts

@@ -0,0 +1,5 @@
+export declare function checkStateRangeValue(value: Record<string, unknown>): boolean;
+export declare function checkStateFilter(filters: Record<string, Array<unknown>>): boolean;
+export declare function checkStateSort(sort: unknown): boolean;
+export declare function checkState(state: Record<string, unknown>): boolean;
+//# sourceMappingURL=typecheck.d.ts.map

package/dist/esm/UrlManager/typecheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typecheck.d.ts","sourceRoot":"","sources":["../../../src/UrlManager/typecheck.ts"],"names":[],"mappings":"AAAA,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAmB5E;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,OAAO,CA4BjF;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAcrD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAkBlE"}

package/dist/esm/UrlManager/typecheck.js

@@ -0,0 +1,66 @@
+export function checkStateRangeValue(value) {
+    if (typeof value != 'object') {
+        return false;
+    }
+    if (typeof value.low != 'number' && value.low !== undefined) {
+        return false;
+    }
+    if (typeof value.high != 'number' && value.high !== undefined) {
+        return false;
+    }
+    if (typeof value.low != 'number' && typeof value.high != 'number') {
+        // at least one must be defined
+        return true;
+    }
+    return true;
+}
+export function checkStateFilter(filters) {
+    for (const key of Object.keys(filters)) {
+        if (typeof key !== 'string') {
+            return false;
+        }
+        const fieldFilter = filters[key];
+        const invalidFilter = fieldFilter.find((filter) => {
+            if (typeof filter == 'string') {
+                return false;
+            }
+            if (typeof filter == 'number') {
+                return false;
+            }
+            if (typeof filter == 'object' && filter !== null) {
+                return !checkStateRangeValue(filter);
+            }
+        });
+        if (invalidFilter) {
+            return false;
+        }
+    }
+    return true;
+}
+export function checkStateSort(sort) {
+    const sortsAsArray = sort instanceof Array ? sort : [sort];
+    for (const sort of sortsAsArray) {
+        if (typeof sort.field != 'string') {
+            return false;
+        }
+        if (typeof sort.direction != 'string') {
+            return false;
+        }
+    }
+    return true;
+}
+export function checkState(state) {
+    if (typeof state.filter == 'object' && !checkStateFilter(state.filter)) {
+        return false;
+    }
+    if (typeof state.sort == 'object' && !checkStateSort(state.sort)) {
+        return false;
+    }
+    if (state.page !== undefined && typeof state.page != 'number') {
+        return false;
+    }
+    if (state.query !== undefined && typeof state.query != 'string') {
+        return false;
+    }
+    return true;
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,5 @@
+export * from './UrlManager/UrlManager';
+export * from './Translators';
+export * from './linkers';
+export { UrlState, Translator } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAE1B,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+export * from './UrlManager/UrlManager';
+export * from './Translators';
+export * from './linkers';

package/dist/esm/linkers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './react/react';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/linkers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/linkers/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dist/esm/linkers/index.js

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

package/dist/esm/linkers/react/react.d.ts

@@ -0,0 +1,8 @@
+import { UrlManager } from '../../UrlManager/UrlManager';
+export declare function reactLinker(urlManager: UrlManager): linkObject;
+declare type linkObject = {
+    href: string;
+    onClick: (e: Event) => void;
+};
+export {};
+//# sourceMappingURL=react.d.ts.map

package/dist/esm/linkers/react/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../../../src/linkers/react/react.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAEzD,wBAAgB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAU9D;AAED,aAAK,UAAU,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;CAC5B,CAAC"}

package/dist/esm/linkers/react/react.js

@@ -0,0 +1,11 @@
+export function reactLinker(urlManager) {
+    return {
+        href: urlManager.href,
+        onClick: (ev) => {
+            if (!urlManager?.detached) {
+                ev.preventDefault();
+            }
+            urlManager.go();
+        },
+    };
+}

package/dist/esm/types.d.ts

@@ -0,0 +1,47 @@
+import type { ImmutableObject } from 'seamless-immutable';
+export declare enum RangeValueProperties {
+    LOW = "low",
+    HIGH = "high"
+}
+export declare type UrlStateRangeValue = {
+    [RangeValueProperties.LOW]: number | null;
+    [RangeValueProperties.HIGH]: number | null;
+};
+export declare type UrlStateFilterType = string | number | boolean | UrlStateRangeValue;
+export declare type UrlStateFilter = {
+    [fieldName: string]: UrlStateFilterType | Array<UrlStateFilterType>;
+};
+export declare type UrlStateSort = {
+    field: string;
+    direction: string;
+};
+export declare type UrlState = {
+    page?: number;
+    pageSize?: number;
+    query?: string;
+    rq?: string;
+    oq?: string;
+    filter?: UrlStateFilter;
+    sort?: UrlStateSort | Array<UrlStateSort>;
+    tag?: string;
+    [any: string]: unknown;
+};
+export interface Translator {
+    getCurrentUrl(): string;
+    getConfig(): Record<string, unknown>;
+    serialize(state: UrlState | ImmutableObject<UrlState>): string;
+    deserialize(url: string): UrlState;
+    bindExternalEvents?(update: () => void): void;
+    go(url: string, config?: {
+        [any: string]: unknown;
+    }): void;
+}
+export interface TranslatorConfig {
+    queryParameter?: string;
+    urlRoot?: string;
+}
+export declare enum ParamLocationType {
+    HASH = "hash",
+    QUERY = "query"
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,oBAAY,oBAAoB;IAC/B,GAAG,QAAQ;IACX,IAAI,SAAS;CACb;AAED,oBAAY,kBAAkB,GAAG;IAChC,CAAC,oBAAoB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1C,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3C,CAAC;AAEF,oBAAY,kBAAkB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,kBAAkB,CAAC;AAEhF,oBAAY,cAAc,GAAG;IAC5B,CAAC,SAAS,EAAE,MAAM,GAAG,kBAAkB,GAAG,KAAK,CAAC,kBAAkB,CAAC,CAAC;CACpE,CAAC;AAEF,oBAAY,YAAY,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,oBAAY,QAAQ,GAAG;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,IAAI,CAAC,EAAE,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC,CAAC;IAC1C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB,CAAC;AAEF,MAAM,WAAW,UAAU;IAC1B,aAAa,IAAI,MAAM,CAAC;IACxB,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAErC,SAAS,CAAC,KAAK,EAAE,QAAQ,GAAG,eAAe,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC;IAC/D,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC;IAEnC,kBAAkB,CAAC,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAE9C,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;CAC3D;AAED,MAAM,WAAW,gBAAgB;IAChC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,oBAAY,iBAAiB;IAC5B,IAAI,SAAS;IACb,KAAK,UAAU;CACf"}

package/dist/esm/types.js

@@ -0,0 +1,10 @@
+export var RangeValueProperties;
+(function (RangeValueProperties) {
+    RangeValueProperties["LOW"] = "low";
+    RangeValueProperties["HIGH"] = "high";
+})(RangeValueProperties || (RangeValueProperties = {}));
+export var ParamLocationType;
+(function (ParamLocationType) {
+    ParamLocationType["HASH"] = "hash";
+    ParamLocationType["QUERY"] = "query";
+})(ParamLocationType || (ParamLocationType = {}));

package/package.json

@@ -0,0 +1,31 @@
+{
+	"name": "@searchspring/snap-url-manager",
+	"version": "0.20.0",
+	"description": "Snap URL Manager",
+	"main": "dist/cjs/index.js",
+	"module": "dist/esm/index.js",
+	"author": "Searchspring",
+	"license": "MIT",
+	"repository": "https://github.com/searchspring/snap",
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "rm -rf ./dist && tsc && tsc -p tsconfig.cjs.json",
+		"build:docs": "typedoc --out docs src/index.ts",
+		"dev": "tsc --watch",
+		"format": "prettier --write 'src/**/*.{js,jsx,ts,tsx}'",
+		"lint": "eslint 'src/**/*.{js,jsx,ts,tsx}'",
+		"test": "jest",
+		"test:watch": "jest --watch"
+	},
+	"dependencies": {
+		"deepmerge": "^4.2.2",
+		"seamless-immutable": "^7.1.4"
+	},
+	"sideEffects": false,
+	"files": [
+		"dist/**/*"
+	],
+	"gitHead": "122405b27b497c7bb6a189c30535fdc197bc3ef0"
+}