@nu-art/thunderstorm-frontend 0.400.5

package/core/Thunder.js

@@ -0,0 +1,139 @@
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { BeLogged, exists, ImplementationMissingException, LogClient_BrowserGroups, merge, ModuleManager, Promise_all_sequentially, removeItemFromArray } from '@nu-art/ts-common';
+import { ThunderDispatcher } from './thunder-dispatcher.js';
+import '../styles/impl/basic.scss';
+import '../styles/impl/icons.scss';
+import * as RDC from 'react-dom/client';
+import { appWithJSX } from './AppWrapper.js';
+import { StorageKey } from '../modules/ModuleFE_LocalStorage.js';
+import axios from 'axios';
+import { getBrowseAndDeviceLogs, getECMADataLog, getiFrameLog, getJSEngineLogs, globalErrorListener, indexedDBAsyncCheckLog, navigationTimingLog } from './thunder-helpers.js';
+export const Storage_AppVersion = new StorageKey('app-version').withstandDeletion();
+export class Thunder extends ModuleManager {
+    listeners = [];
+    renderFunc;
+    props;
+    preBuildActions = [];
+    innerConfig;
+    constructor(config) {
+        super();
+        BeLogged.addClient(LogClient_BrowserGroups);
+        // @ts-ignore
+        window.thunder = this;
+        // @ts-ignore
+        ThunderDispatcher['listenersResolver'] = () => this.listeners;
+        this.addPreBuildAction(this.fetchConfig.bind(this)); // add config resolver as a pre build action
+        this.innerConfig = Object.freeze(config);
+    }
+    static getInstance() {
+        return Thunder.instance;
+    }
+    init() {
+        super.init();
+        const appJsx = this.renderFunc?.(this.props);
+        if (!appJsx)
+            throw new ImplementationMissingException('Could not get app from Thunder!');
+        //Set root div and its attributes
+        const rootDiv = document.createElement('div');
+        rootDiv.classList.add('match_parent');
+        rootDiv.setAttribute('id', 'root');
+        document.body.appendChild(rootDiv);
+        //Set app root
+        RDC.createRoot(rootDiv).render(appJsx);
+        return this;
+    }
+    async fetchConfig() {
+        try {
+            this.config = {};
+            const promises = [];
+            if (this.innerConfig.defaultConfigUrl)
+                promises.push(axios.get(this.innerConfig.defaultConfigUrl));
+            else
+                promises.push((async () => ({ data: {} }))());
+            promises.push(axios.get(this.innerConfig.configUrl));
+            const [defaultConfig, envConfig] = await Promise.all(promises);
+            if (!exists(defaultConfig?.data))
+                return this.logWarning('Could not resolve default config');
+            if (!exists(envConfig?.data))
+                return this.logWarning('Could not resolve env config');
+            if (typeof defaultConfig?.data !== 'object')
+                return this.logWarning('default config is not an object');
+            if (typeof envConfig?.data !== 'object')
+                return this.logWarning('env config is not an object');
+            this.config = merge(merge(this.config, defaultConfig.data), envConfig.data);
+        }
+        catch (err) {
+            this.logError('failed loading config with error', err);
+        }
+    }
+    addUIListener(listener) {
+        this.logVerbose(`Register UI listener: ${listener}`);
+        this.listeners.push(listener);
+    }
+    removeUIListener(listener) {
+        this.logVerbose(`Unregister UI listener: ${listener}`);
+        removeItemFromArray(this.listeners, listener);
+    }
+    /**
+     * Set up the entry point for the app.
+     * @param mainApp - The entry point into the application, what will be rendered directly under root (usually App.tsx)
+     * @param props - The props to go with the supplied main app
+     * @param renderFunc - The app wrapper, which will usually provide a router. by default is "appWithJSX" which will just return the app
+     */
+    setMainApp(mainApp, props = {}, renderFunc = appWithJSX) {
+        this.props = {
+            element: mainApp,
+            props: props
+        };
+        this.renderFunc = renderFunc;
+        return this;
+    }
+    build(onStarted) {
+        Promise_all_sequentially(this.preBuildActions).then(() => {
+            super.build();
+            onStarted?.();
+        });
+    }
+    setVersion(version) {
+        Storage_AppVersion.set(version);
+        return super.setVersion(version);
+    }
+    getConfig() {
+        return this.config;
+    }
+    addPreBuildAction = (func) => {
+        this.preBuildActions.push(func);
+        return this;
+    };
+    logStuff = () => {
+        getBrowseAndDeviceLogs();
+        getJSEngineLogs();
+        getECMADataLog();
+        getiFrameLog();
+        navigationTimingLog();
+        globalErrorListener();
+        indexedDBAsyncCheckLog();
+    };
+    getEnvironment() {
+        return Thunder.getInstance().getConfig().label;
+    }
+}

package/core/ThunderstormDefaultApp.d.ts

@@ -0,0 +1,12 @@
+import { ComponentSync } from './ComponentSync.js';
+import { TS_Route } from '../modules/routing/types.js';
+import * as React from 'react';
+export declare class ThunderstormDefaultApp extends ComponentSync<{
+    rootRoute: TS_Route;
+    additionalOverlays?: React.ElementType[];
+}> {
+    static blockEvent<T>(ev: React.DragEvent<T>): void;
+    getAdditionalOverlayRenderer(overlay: React.ElementType): import("react/jsx-runtime").JSX.Element;
+    protected deriveStateFromProps(nextProps: {}): {};
+    render(): import("react/jsx-runtime").JSX.Element;
+}

package/core/ThunderstormDefaultApp.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ComponentSync } from './ComponentSync.js';
+import { generateUUID } from '@nu-art/ts-common';
+import { Thunder } from './Thunder.js';
+import { stopPropagation } from '../utils/tools.js';
+import { ModuleFE_RoutingV2 } from '../modules/routing/ModuleFE_RoutingV2.js';
+import { TS_DialogOverlay } from '../components/TS_Dialog/index.js';
+import { TS_PopUp, TS_ToolTip } from '../components/TS_MouseInteractivity/index.js';
+import { TS_ToastOverlay } from '../components/TS_Toaster/index.js';
+import { TS_Notifications } from '../components/TS_Notifications/index.js';
+import { TS_MemoryMonitor } from '../components/TS_MemoryMonitor/index.js';
+export class ThunderstormDefaultApp extends ComponentSync {
+    static blockEvent(ev) {
+        ev.preventDefault();
+        ev.stopPropagation();
+    }
+    getAdditionalOverlayRenderer(overlay) {
+        const Renderer = overlay;
+        return _jsx(Renderer, {}, generateUUID());
+    }
+    deriveStateFromProps(nextProps) {
+        return {};
+    }
+    render() {
+        // @ts-ignore
+        const blockRightClick = !Thunder.getInstance().config.isDebug;
+        return (_jsxs("div", { id: "app", onDrop: stopPropagation, onDragOver: stopPropagation, onContextMenu: blockRightClick ? stopPropagation : undefined, children: [ModuleFE_RoutingV2.generateRoutes(this.props.rootRoute), _jsx(TS_DialogOverlay, {}), _jsx(TS_PopUp, {}), _jsx(TS_ToolTip, {}), _jsx(TS_ToastOverlay, {}), _jsx(TS_Notifications, {}), _jsx(TS_MemoryMonitor, {}), this.props.additionalOverlays?.map(Overlay => this.getAdditionalOverlayRenderer(Overlay))] }));
+    }
+}

package/core/consts.d.ts

@@ -0,0 +1,6 @@
+import { ThunderDispatcher } from './thunder-dispatcher.js';
+import { ReactNode } from 'react';
+export interface OnPageTitleChangedListener {
+    __onPageTitleChanged(title: ReactNode): void;
+}
+export declare const dispatch_onPageTitleChanged: ThunderDispatcher<OnPageTitleChangedListener, "__onPageTitleChanged", [title: ReactNode], void>;

package/core/consts.js

@@ -0,0 +1,2 @@
+import { ThunderDispatcher } from './thunder-dispatcher.js';
+export const dispatch_onPageTitleChanged = new ThunderDispatcher('__onPageTitleChanged');

package/core/db-api-gen/consts.d.ts

@@ -0,0 +1,22 @@
+import { ThunderDispatcher } from '../thunder-dispatcher.js';
+import { OnSyncStatusChangedListener } from './types.js';
+export declare enum SyncStatus {
+    loading = 0,
+    idle = 1,
+    read = 2,
+    write = 3
+}
+export declare enum DataStatus {
+    NoData = 0,//no render
+    UpdatingData = 1,//no render
+    ContainsData = 2
+}
+export declare const syncDispatcher: ThunderDispatcher<OnSyncStatusChangedListener<any>, '__onSyncStatusChanged'>;
+export declare const EventType_UpsertAll = "upsert-all";
+export declare const EventType_Create = "create";
+export declare const EventType_Update = "update";
+export declare const EventType_Patch = "patch";
+export declare const EventType_Unique = "unique";
+export declare const EventType_Query = "query";
+export declare const EventType_Delete = "delete";
+export declare const EventType_DeleteMulti = "delete-multi";

package/core/db-api-gen/consts.js

@@ -0,0 +1,25 @@
+import { ThunderDispatcher } from '../thunder-dispatcher.js';
+export var SyncStatus;
+(function (SyncStatus) {
+    SyncStatus[SyncStatus["loading"] = 0] = "loading";
+    SyncStatus[SyncStatus["idle"] = 1] = "idle";
+    SyncStatus[SyncStatus["read"] = 2] = "read";
+    SyncStatus[SyncStatus["write"] = 3] = "write";
+})(SyncStatus || (SyncStatus = {}));
+export var DataStatus;
+(function (DataStatus) {
+    DataStatus[DataStatus["NoData"] = 0] = "NoData";
+    DataStatus[DataStatus["UpdatingData"] = 1] = "UpdatingData";
+    DataStatus[DataStatus["ContainsData"] = 2] = "ContainsData";
+    // UpdatingDelta, //render
+    // UpToDate//render
+})(DataStatus || (DataStatus = {}));
+export const syncDispatcher = new ThunderDispatcher('__onSyncStatusChanged');
+export const EventType_UpsertAll = 'upsert-all';
+export const EventType_Create = 'create';
+export const EventType_Update = 'update';
+export const EventType_Patch = 'patch';
+export const EventType_Unique = 'unique';
+export const EventType_Query = 'query';
+export const EventType_Delete = 'delete';
+export const EventType_DeleteMulti = 'delete-multi';

package/core/db-api-gen/db-def.d.ts

@@ -0,0 +1,9 @@
+import { DBDef_V3, DBProto } from '@nu-art/ts-common';
+import { DBConfigV3 } from '../IndexedDBV4/types.js';
+export type DBApiFEConfig<Proto extends DBProto<any>> = {
+    key: string;
+    versions: Proto['versions'];
+    validator: Proto['modifiablePropsValidator'];
+    dbConfig: DBConfigV3<Proto>;
+};
+export declare const getModuleFEConfigV3: <Proto extends DBProto<any>>(dbDef: DBDef_V3<Proto>) => DBApiFEConfig<Proto>;

package/core/db-api-gen/db-def.js

@@ -0,0 +1,16 @@
+import { Const_UniqueKey, DefaultDBVersion } from '@nu-art/ts-common';
+export const getModuleFEConfigV3 = (dbDef) => {
+    return {
+        key: dbDef.dbKey,
+        versions: dbDef.versions || [DefaultDBVersion],
+        validator: dbDef.modifiablePropsValidator,
+        dbConfig: {
+            version: dbDef.versions[0],
+            name: dbDef.frontend.name,
+            group: dbDef.frontend.group,
+            indices: dbDef.indices,
+            autoIncrement: false,
+            uniqueKeys: dbDef.uniqueKeys || [Const_UniqueKey]
+        },
+    };
+};

package/core/db-api-gen/types.d.ts

@@ -0,0 +1,23 @@
+import { DBProto } from '@nu-art/ts-common';
+import { ThunderDispatcher } from '../thunder-dispatcher.js';
+import { ModuleFE_BaseDB } from '../../modules/db-api-gen/ModuleFE_BaseDB.js';
+export type SingleApiEvent = 'create' | 'update' | 'unique' | 'delete' | 'patch';
+export type MultiApiEvent = 'query' | 'upsert-all' | 'sync' | 'delete-multi';
+export type ApiCallerEventType<Proto extends DBProto<any>> = [
+    SingleApiEvent,
+    Proto['dbType']
+] | [MultiApiEvent, Proto['dbType'][]];
+export interface OnSyncStatusChangedListener<Proto extends DBProto<any>> {
+    __onSyncStatusChanged: (module: ModuleFE_BaseDB<Proto['dbType'], any>) => void;
+}
+export type DispatcherInterface<Def extends DispatcherDef<any, any>> = {
+    [K in Def['eventName']]: Def['method'];
+};
+export type DispatcherDef<Proto extends DBProto<any>, MethodName extends `${'__'}${string}`> = {
+    eventName: MethodName;
+    method: (...params: ApiCallerEventType<Proto>) => void;
+};
+export declare class ThunderDispatcherV3<T extends DispatcherDef<any, any>> extends ThunderDispatcher<{
+    [K in T['eventName']]: T['method'];
+}, T['eventName']> {
+}

package/core/db-api-gen/types.js

@@ -0,0 +1,3 @@
+import { ThunderDispatcher } from '../thunder-dispatcher.js';
+export class ThunderDispatcherV3 extends ThunderDispatcher {
+}

package/core/proto-component/ProtoComponent.d.ts

@@ -0,0 +1,57 @@
+import { ComponentSync } from '../ComponentSync.js';
+import { OnUrlParamsChangedListenerV2 } from '../../modules/ModuleFE_BrowserHistoryV2.js';
+import { ProtoComponentDef } from './types.js';
+/**
+ * @abstract
+ * @class
+ * Expansion on ComponentSync, this component takes a [ProtoComponentDef]{@link ProtoComponentDef} type that
+ * defines its interaction with the URL hash. </br>
+ * Constrained by the [ProtoComponentDef]{@link ProtoComponentDef}, the component will take an array of query param keys (string[]), and generate, provide functionality
+ * and listen on changes in the URL hash. </br>
+ * @augments ComponentSync
+ * @implements OnUrlParamsChangedListenerV2
+ * @copyright nu-art
+ */
+export declare abstract class ProtoComponent<Def extends ProtoComponentDef<any, any>, P extends {} = {}, S extends {} = {}, Props extends Def['props'] & P = Def['props'] & P, State extends Def['state'] & S = Def['state'] & S> extends ComponentSync<Props, State> implements OnUrlParamsChangedListenerV2 {
+    /**
+     * Listener for URL changes triggered by ModuleFE_BrowserHistoryV2.
+     * Will trigger deriveStateFromProps with the new state of the query params set to be the previous state,
+     * if there were changes in the hash that are relevant to this component.
+     */
+    __onUrlParamsChangedV2: () => void;
+    /**
+     * Generates an object connection each query param key given in the props to its current value as read from the URL
+     */
+    private getQueryParamResultsObject;
+    /**
+     * Will set a value in the URL hash for a given key.
+     * @param key
+     * @param value
+     */
+    setQueryParam<K extends Def['queryParamKeys'] = Def['queryParamKeys']>(key: K, value: Def['queryParamDef'][K]): void;
+    /**
+     * Retrieves the value of the specified query parameter.
+     *
+     * @param {K} key - The query parameter key.
+     * @return {Def['queryParamDef'][K] | undefined} - The value of the specified query parameter, or undefined if it doesn't exist.
+     */
+    getQueryParam<K extends Def['queryParamKeys']>(key: K): Readonly<Def['queryParamDef'][K]> | undefined;
+    /**
+     * Retrieves the value of the specified query parameter from the URL.
+     *
+     * @param {K} key - The key of the query parameter to retrieve. Must be one of the defined query parameter keys.
+     * @param {Def.queryParamDef[K]} defaultValue - The default value to return if the query parameter is not found in the URL.
+     * @returns {Def.queryParamDef[K]} - The value of the specified query parameter, or the default value if not found.
+     */
+    getQueryParam<K extends Def['queryParamKeys']>(key: K, defaultValue: Def['queryParamDef'][K]): Readonly<Def['queryParamDef'][K]>;
+    /**
+     * Clears the value of a query param by a given key
+     * @param key
+     */
+    deleteQueryParam(key: Def['queryParamKeys']): void;
+    /**
+     * Will merge the given query object into the URL.
+     * @param query
+     */
+    setQueryParams(query: Partial<Def['queryParamDef']>): void;
+}

package/core/proto-component/ProtoComponent.js

@@ -0,0 +1,73 @@
+import { ComponentSync } from '../ComponentSync.js';
+import { BadImplementationException, compare, deepClone } from '@nu-art/ts-common';
+import { ModuleFE_BrowserHistoryV2 } from '../../modules/ModuleFE_BrowserHistoryV2.js';
+/**
+ * @abstract
+ * @class
+ * Expansion on ComponentSync, this component takes a [ProtoComponentDef]{@link ProtoComponentDef} type that
+ * defines its interaction with the URL hash. </br>
+ * Constrained by the [ProtoComponentDef]{@link ProtoComponentDef}, the component will take an array of query param keys (string[]), and generate, provide functionality
+ * and listen on changes in the URL hash. </br>
+ * @augments ComponentSync
+ * @implements OnUrlParamsChangedListenerV2
+ * @copyright nu-art
+ */
+export class ProtoComponent extends ComponentSync {
+    // ######################## Life Cycle ########################
+    /**
+     * Listener for URL changes triggered by ModuleFE_BrowserHistoryV2.
+     * Will trigger deriveStateFromProps with the new state of the query params set to be the previous state,
+     * if there were changes in the hash that are relevant to this component.
+     */
+    __onUrlParamsChangedV2 = () => {
+        const previousResultsObject = this.state?.previousResultsObject;
+        const queryParams = this.getQueryParamResultsObject();
+        const hasChanges = !compare(queryParams, previousResultsObject);
+        this.logDebug(`Query params has changes: ${hasChanges}`, previousResultsObject, queryParams);
+        if (hasChanges) {
+            this.reDeriveState({ previousResultsObject: deepClone(queryParams) });
+        }
+    };
+    // ######################## Class Methods ########################
+    /**
+     * Generates an object connection each query param key given in the props to its current value as read from the URL
+     */
+    getQueryParamResultsObject() {
+        try {
+            return this.props.keys.reduce((map, key) => {
+                map[key] = this.getQueryParam(key);
+                return map;
+            }, {});
+        }
+        catch (err) {
+            throw new BadImplementationException('proto component implementation must implement default props with keys', err);
+        }
+    }
+    // ######################## Singulars
+    /**
+     * Will set a value in the URL hash for a given key.
+     * @param key
+     * @param value
+     */
+    setQueryParam(key, value) {
+        ModuleFE_BrowserHistoryV2.set(key, value);
+    }
+    getQueryParam(key, defaultValue) {
+        return ModuleFE_BrowserHistoryV2.get(key) ?? Object.freeze(defaultValue);
+    }
+    /**
+     * Clears the value of a query param by a given key
+     * @param key
+     */
+    deleteQueryParam(key) {
+        ModuleFE_BrowserHistoryV2.delete(key);
+    }
+    // ######################## Multiples
+    /**
+     * Will merge the given query object into the URL.
+     * @param query
+     */
+    setQueryParams(query) {
+        ModuleFE_BrowserHistoryV2.setObject(query);
+    }
+}

package/core/proto-component/UrlState.d.ts

@@ -0,0 +1,42 @@
+import { ProtoComponentDef } from './types.js';
+import { Logger } from '@nu-art/ts-common';
+import { ComponentSync } from '../ComponentSync.js';
+export declare class UrlState<Def extends ProtoComponentDef<any, any>> extends Logger {
+    private keys;
+    constructor(keys: Def['props']['keys'], _component: ComponentSync<any, any>);
+    /**
+     * Generates an object connection each query param key given in the props to its current value as read from the URL
+     */
+    private getQueryParamResultsObject;
+    /**
+     * Will set a value in the URL hash for a given key.
+     * @param key
+     * @param value
+     */
+    setQueryParam<K extends Def['queryParamKeys'] = Def['queryParamKeys']>(key: K, value: Def['queryParamDef'][K]): void;
+    /**
+     * Retrieves the value of the specified query parameter.
+     *
+     * @param {K} key - The query parameter key.
+     * @return {Def['queryParamDef'][K] | undefined} - The value of the specified query parameter, or undefined if it doesn't exist.
+     */
+    getQueryParam<K extends Def['queryParamKeys']>(key: K): Readonly<Def['queryParamDef'][K]> | undefined;
+    /**
+     * Retrieves the value of the specified query parameter from the URL.
+     *
+     * @param {K} key - The key of the query parameter to retrieve. Must be one of the defined query parameter keys.
+     * @param {Def.queryParamDef[K]} defaultValue - The default value to return if the query parameter is not found in the URL.
+     * @returns {Def.queryParamDef[K]} - The value of the specified query parameter, or the default value if not found.
+     */
+    getQueryParam<K extends Def['queryParamKeys']>(key: K, defaultValue: Def['queryParamDef'][K]): Readonly<Def['queryParamDef'][K]>;
+    /**
+     * Clears the value of a query param by a given key
+     * @param key
+     */
+    deleteQueryParam(key: Def['queryParamKeys']): void;
+    /**
+     * Will merge the given query object into the URL.
+     * @param query
+     */
+    setQueryParams(query: Partial<Def['queryParamDef']>): void;
+}

package/core/proto-component/UrlState.js

@@ -0,0 +1,59 @@
+import { BadImplementationException, compare, deepClone, Logger } from '@nu-art/ts-common';
+import { ModuleFE_BrowserHistoryV2 } from '../../modules/ModuleFE_BrowserHistoryV2.js';
+export class UrlState extends Logger {
+    keys;
+    constructor(keys, _component) {
+        super();
+        this.keys = keys;
+        const component = _component;
+        component.__onUrlParamsChangedV2 = () => {
+            const previousResultsObject = component.state?.previousResultsObject;
+            const queryParams = this.getQueryParamResultsObject();
+            const hasChanges = !compare(queryParams, previousResultsObject);
+            this.logDebug(`Query params has changes: ${hasChanges}`, previousResultsObject, queryParams);
+            if (!hasChanges)
+                return;
+            component.reDeriveState({ previousResultsObject: deepClone(queryParams) });
+        };
+    }
+    /**
+     * Generates an object connection each query param key given in the props to its current value as read from the URL
+     */
+    getQueryParamResultsObject() {
+        try {
+            return this.keys.reduce((map, key) => {
+                map[key] = this.getQueryParam(key);
+                return map;
+            }, {});
+        }
+        catch (err) {
+            throw new BadImplementationException('proto component implementation must implement default props with keys', err);
+        }
+    }
+    /**
+     * Will set a value in the URL hash for a given key.
+     * @param key
+     * @param value
+     */
+    setQueryParam(key, value) {
+        ModuleFE_BrowserHistoryV2.set(key, value);
+    }
+    getQueryParam(key, defaultValue) {
+        return ModuleFE_BrowserHistoryV2.get(key) ?? Object.freeze(defaultValue);
+    }
+    /**
+     * Clears the value of a query param by a given key
+     * @param key
+     */
+    deleteQueryParam(key) {
+        ModuleFE_BrowserHistoryV2.delete(key);
+    }
+    // ######################## Multiples
+    /**
+     * Will merge the given query object into the URL.
+     * @param query
+     */
+    setQueryParams(query) {
+        ModuleFE_BrowserHistoryV2.setObject(query);
+    }
+}

package/core/proto-component/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './ProtoComponent.js';

package/core/proto-component/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './ProtoComponent.js';

package/core/proto-component/types.d.ts

@@ -0,0 +1,25 @@
+import { Primitive, RecursiveArrayOfPrimitives, RecursiveObjectOfPrimitives, SubsetObjectByKeys } from '@nu-art/ts-common';
+export type ProtoComponentDefV2<ParamTypes extends {
+    [K in ParamKeys]: Primitive | RecursiveObjectOfPrimitives | RecursiveArrayOfPrimitives;
+}, ParamKeys extends keyof ParamTypes = keyof ParamTypes> = ParamKeys extends string ? ProtoComponentDef<ParamKeys, ParamTypes> : never;
+/**
+ * A Definition type for the [ProtoComponent]{@link ProtoComponent}, this type takes 2 arguments:</br>
+ * QPK - a list of URL param keys this def will deal with</br>
+ * QPD - an object describing the value types for the keys in QPK, no different from a React state definition.
+ */
+export type ProtoComponentDef<ParamKeys extends string, ParamTypes extends {
+    [K in ParamKeys]: Primitive | RecursiveObjectOfPrimitives | RecursiveArrayOfPrimitives;
+}> = {
+    queryParamKeys: ParamKeys;
+    queryParamDef: SubsetObjectByKeys<ParamTypes, ParamKeys>;
+    props: {
+        keys: ParamKeys[];
+    };
+    state: {
+        previousResultsObject?: {
+            [Key in ParamKeys]: ParamTypes[Key];
+        };
+    };
+};
+export type SubProto<Def extends ProtoComponentDef<any, any>, Keys extends Def['queryParamKeys']> = ProtoComponentDef<Keys, Def['queryParamDef']>;
+export type SuperProto<Def1 extends ProtoComponentDef<any, any>, Def2 extends ProtoComponentDef<any, any>> = ProtoComponentDef<Def1['queryParamKeys'] | Def2['queryParamKeys'], Def1['queryParamDef'] & Def2['queryParamDef']>;

package/core/proto-component/types.js

@@ -0,0 +1,15 @@
+export {};
+// export type Test1 = ProtoComponentDef<'pah' | 'ashpa', { pah: string, zevel: string, ashpa: string }>
+// export type Test2 = SubProto<Test1, 'ashpa'>
+// export type Test3 = SubProto<Test1, 'pah'>
+// export type Test4 = SuperProto<Test2, Test3>
+// const t: Test4 = {
+// 	queryParamDef: {
+// 		'pah': 'qd',
+// 		'ashpa': 'asd',
+// 		'zevel': 'asdas'
+// 	},
+// 	props: {
+// 		queryParamsKeys: ['pah', 'ashpa']
+// 	}
+// };

package/core/thunder-dispatcher.d.ts

@@ -0,0 +1,13 @@
+import { Dispatcher, FunctionKeys, LogLevel, ParamResolver, ReturnTypeResolver } from '@nu-art/ts-common';
+export declare class ThunderDispatcher<T, K extends FunctionKeys<T>, P extends ParamResolver<T, K> = ParamResolver<T, K>, R extends ReturnTypeResolver<T, K> = ReturnTypeResolver<T, K>> extends Dispatcher<T, K, P, R> {
+    static MinLogLevel: LogLevel;
+    static readonly listenersResolver: () => any[];
+    private cache?;
+    private allowCache;
+    constructor(method: K, allowCache?: boolean);
+    getCachedData(): P | undefined;
+    dispatchUI(...p: P): R[];
+    dispatchUIAsync(...p: P): Promise<R[]>;
+    dispatchAll(...p: P): R[];
+    dispatchAllAsync(...p: P): Promise<R[]>;
+}