taon 0.0.0 → 18.0.12

package/websql/lib/realtime/realtime-strategy/index.d.ts

@@ -0,0 +1,5 @@
+// @ts-nocheck
+export * from './realtime-strategy';
+export * from './realtime-strategy-ipc';
+export * from './realtime-strategy-mock';
+export * from './realtime-strategy-socket-io';

package/websql/lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-main-namespace.d.ts

@@ -0,0 +1,22 @@
+// @ts-nocheck
+export declare class IpcMainNamespace {
+    name: string;
+    private rooms;
+    private listeners;
+    constructor(name: string);
+    on(event: string, callback: (event: Electron.IpcMainEvent, ...args: any[]) => void): any;
+    off(event: string, callback?: (event: Electron.IpcMainEvent, ...args: any[]) => void): any;
+    emit(event: string, ...args: any[]): any;
+    to(room: string): {
+        emit: (event: string, ...args: any[]) => void;
+    };
+    in(room: string): {
+        emit: (event: string, ...args: any[]) => void;
+    };
+    join(webContents: Electron.WebContents, room: string): void;
+    leave(webContents: Electron.WebContents, room: string): void;
+    path(): string;
+    get nsp(): {
+        readonly name: string;
+    };
+}

package/websql/lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-main-wrapper.d.ts

@@ -0,0 +1,17 @@
+// @ts-nocheck
+import { IpcMainNamespace } from './realtime-strategy-ipc-main-namespace';
+export declare class ioIpcStrategy {
+    contextName: string;
+    private namespaces;
+    constructor(contextName: string);
+    of(namespace: string): IpcMainNamespace;
+    on(event: string, callback: (event: Electron.IpcMainEvent, ...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): void;
+    path(): string;
+    get nsp(): {
+        readonly name: string;
+    };
+    in(room: string): {
+        emit: (event: string, ...args: any[]) => void;
+    };
+}

package/websql/lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-renderer-namespace.d.ts

@@ -0,0 +1,11 @@
+// @ts-nocheck
+import { ipcRenderer } from 'electron';
+export declare class IpcRendererNamespace {
+    name: string;
+    ipcRenderer: typeof ipcRenderer;
+    private listeners;
+    constructor(name: string);
+    on(eventName: string, callback: (event: any, ...args: any[]) => void): void;
+    off(event: string, callback?: (event: any, ...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): void;
+}

package/websql/lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-renderer-wrapper.d.ts

@@ -0,0 +1,11 @@
+// @ts-nocheck
+import { IpcRendererNamespace } from './realtime-strategy-ipc-renderer-namespace';
+export declare class IpcRendererWrapper {
+    contextName: string;
+    private namespaces;
+    private connected;
+    constructor(contextName: string);
+    of(namespace: string): IpcRendererNamespace;
+    on(event: string, callback: (event: any, ...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): void;
+}

package/websql/lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc.models.d.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import { IpcMainNamespace } from './realtime-strategy-ipc-main-namespace';
+export interface RendererEventListeners {
+    [event: string]: Array<(event: any, ...args: any[]) => void>;
+}
+export interface EventListeners {
+    [event: string]: Array<(event: Electron.IpcMainEvent, ...args: any[]) => void>;
+}
+export interface Rooms {
+    [room: string]: Set<Electron.WebContents>;
+}
+export interface Namespaces {
+    [namespace: string]: IpcMainNamespace;
+}

package/websql/lib/realtime/realtime-strategy/realtime-strategy-ipc.d.ts

@@ -0,0 +1,23 @@
+// @ts-nocheck
+import { Server } from 'socket.io';
+import { EndpointContext } from '../../endpoint-context';
+import { RealtimeStrategy } from './realtime-strategy';
+import type { io } from 'socket.io-client';
+/**
+ * Purpose:
+ * - backend-browser communication between 2 processes in electron mode
+ */
+export declare class RealtimeStrategyIpc extends RealtimeStrategy {
+    protected ctx: EndpointContext;
+    toString(): string;
+    establishConnection(): void;
+    constructor(ctx: EndpointContext);
+    contextsServers: {
+        [contextName: string]: Server;
+    };
+    contextsIO: {
+        [contextName: string]: typeof io;
+    };
+    get io(): any;
+    get Server(): any;
+}

package/websql/lib/realtime/realtime-strategy/realtime-strategy-mock-models/index.d.ts

@@ -0,0 +1,3 @@
+// @ts-nocheck
+export * from './realtime-strategy-mock-server';
+export * from './realtime-strategy-mock-client';

package/websql/lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-client.d.ts

@@ -0,0 +1,17 @@
+// @ts-nocheck
+import { MockServer } from "./realtime-strategy-mock-server";
+import { MockSocket } from "./realtime-strategy-mock-socket";
+declare class MockClientSocket {
+    private serverSocket;
+    contextName: string;
+    private listeners;
+    constructor(serverSocket: MockSocket, contextName: string);
+    on(event: string, callback: (data?: any) => void): void;
+    off(event: string, callback?: (data?: any) => void): void;
+    emit(event: string, data?: any): void;
+    disconnect(): void;
+    join(room: string): void;
+    leave(room: string): void;
+}
+export declare function mockIo(server: MockServer): (namespace?: string) => MockClientSocket;
+export {};

package/websql/lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-namespaces.d.ts

@@ -0,0 +1,18 @@
+// @ts-nocheck
+import { MockSocket } from "./realtime-strategy-mock-socket";
+export declare class MockNamespace {
+    name: string;
+    contextName: string;
+    private rooms;
+    private sockets;
+    constructor(name: string, contextName: string);
+    on(event: string, callback: (socket: MockSocket) => void): void;
+    emit(event: string, data?: any): void;
+    to(room: string): {
+        emit: (event: string, data?: any) => void;
+    };
+    joinRoom(socket: MockSocket, room: string): void;
+    leaveRoom(socket: MockSocket, room: string): void;
+    addSocket(socket: MockSocket): void;
+    removeSocket(socket: MockSocket): void;
+}

package/websql/lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-server.d.ts

@@ -0,0 +1,12 @@
+// @ts-nocheck
+import { MockNamespace } from "./realtime-strategy-mock-namespaces";
+import { MockSocket } from "./realtime-strategy-mock-socket";
+export declare class MockServer {
+    contextName: string;
+    private namespaces;
+    constructor(contextName: string);
+    of(namespace: string): MockNamespace;
+    on(event: string, callback: (socket: MockSocket) => void): void;
+    emit(event: string, data?: any): void;
+    connect(id: string, namespace?: string): MockSocket;
+}

package/websql/lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-socket.d.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import { MockNamespace } from "./realtime-strategy-mock-namespaces";
+export declare class MockSocket {
+    id: string;
+    private namespace;
+    private listeners;
+    constructor(id: string, namespace: MockNamespace);
+    on(event: string, callback: (data?: any) => void): void;
+    off(event: string, callback?: (data?: any) => void): void;
+    emit(event: string, data?: any): void;
+    join(room: string): void;
+    leave(room: string): void;
+    disconnect(): void;
+}

package/websql/lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock.models.d.ts

@@ -0,0 +1,12 @@
+// @ts-nocheck
+import { MockNamespace } from "./realtime-strategy-mock-namespaces";
+import { MockSocket } from "./realtime-strategy-mock-socket";
+export interface EventListeners {
+    [event: string]: Array<(data?: any) => void>;
+}
+export interface Rooms {
+    [room: string]: Set<MockSocket>;
+}
+export interface Namespaces {
+    [namespace: string]: MockNamespace;
+}

package/websql/lib/realtime/realtime-strategy/realtime-strategy-mock.d.ts

@@ -0,0 +1,15 @@
+// @ts-nocheck
+import { EndpointContext } from '../../endpoint-context';
+import { RealtimeStrategy } from './realtime-strategy';
+/**
+ * Purpose:
+ * - browser-browser communication mock (in websql mode)
+ */
+export declare class RealtimeStrategyMock extends RealtimeStrategy {
+    protected ctx: EndpointContext;
+    toString(): string;
+    constructor(ctx: EndpointContext);
+    get Server(): any;
+    get io(): any;
+    establishConnection(): void;
+}

package/websql/lib/realtime/realtime-strategy/realtime-strategy-socket-io.d.ts

@@ -0,0 +1,17 @@
+// @ts-nocheck
+import { EndpointContext } from '../../endpoint-context';
+import { RealtimeStrategy } from './realtime-strategy';
+import { io } from 'socket.io-client';
+/**
+ * Purpose:
+ * - backend-browser communication
+ * - backend-backend communication
+ */
+export declare class RealtimeStrategySocketIO extends RealtimeStrategy {
+    protected ctx: EndpointContext;
+    toString(): string;
+    constructor(ctx: EndpointContext);
+    get Server(): any;
+    get io(): typeof io;
+    establishConnection(): void;
+}

package/websql/lib/realtime/realtime-strategy/realtime-strategy.d.ts

@@ -0,0 +1,13 @@
+// @ts-nocheck
+import { EndpointContext } from '../../endpoint-context';
+import type { Server } from 'socket.io';
+import type { io } from 'socket.io-client';
+export declare abstract class RealtimeStrategy {
+    protected ctx: EndpointContext;
+    constructor(ctx: EndpointContext);
+    private testTypes;
+    abstract establishConnection(): void;
+    abstract readonly io: typeof io;
+    abstract readonly Server: typeof Server;
+    abstract toString(): string;
+}

package/websql/lib/realtime/realtime-subs-manager.d.ts

@@ -0,0 +1,15 @@
+// @ts-nocheck
+import { Subscriber } from 'rxjs';
+import { Socket as SocketClient } from 'socket.io-client';
+import { DefaultEventsMap } from 'socket.io/dist/typed-events';
+import { RealtimeModels } from './realtime.models';
+export declare class RealtimeSubsManager {
+    private options;
+    private isListening;
+    private observers;
+    constructor(options: RealtimeModels.SubsManagerOpt);
+    startListenIfNotStarted(realtime: SocketClient<DefaultEventsMap, DefaultEventsMap>): void;
+    add(observer: Subscriber<any>): void;
+    remove(observer: Subscriber<any>): void;
+    private update;
+}

package/websql/lib/realtime/realtime.models.d.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import type { RealtimeCore } from './realtime-core';
+export declare namespace RealtimeModels {
+    type SubsManagerOpt = {
+        core: RealtimeCore;
+        customEvent: string;
+        roomName: string;
+        property: string;
+    };
+    type ChangeOption = {
+        property?: string;
+        customEvent?: string;
+    };
+}

package/websql/lib/storage.d.ts

@@ -0,0 +1,2 @@
+// @ts-nocheck
+export declare const globalPublicStorage: typeof globalThis;

package/websql/lib/symbols.d.ts

@@ -0,0 +1,73 @@
+// @ts-nocheck
+export declare namespace Symbols {
+    const ctxInClassOrClassObj: unique symbol;
+    const classNameStaticProperty: string;
+    const fullClassNameStaticProperty: string;
+    const orignalClass: string;
+    const orignalClassClonesObj: string;
+    const classMethodsNames: string;
+    const REALTIME: {
+        NAMESPACE: (contextName: string) => string;
+        TABLE_CHANGE(contextName: string, tableName: string): string;
+        /**
+         * for backendSocket.in(ROOM_NAME).emit(EVENT)
+         *
+         * Room names are uniqe..
+         * here I am limiting number of event for clients.
+         */
+        ROOM_NAME: {
+            CUSTOM(contextName: string, customEvent: string): string;
+            /**
+             * @LAST TODO
+             */
+            SUBSCRIBER_EVENT(contextName: string, className: string, propertyName: string): string;
+            UPDATE_ENTITY(contextName: string, className: string, entityId: number | string): string;
+            UPDATE_ENTITY_PROPERTY(contextName: string, className: string, property: string, entityId: number | string): string;
+            SUBSCRIBE: {
+                CUSTOM: (contextName: string) => string;
+                ENTITY_UPDATE_EVENTS: (contextName: string) => string;
+                ENTITY_PROPERTY_UPDATE_EVENTS: (contextName: string) => string;
+            };
+            UNSUBSCRIBE: {
+                CUSTOM: (contextName: string) => string;
+                ENTITY_UPDATE_EVENTS: (contextName: string) => string;
+                ENTITY_PROPERTY_UPDATE_EVENTS: (contextName: string) => string;
+            };
+        };
+    };
+    const metadata: {
+        className: string;
+        options: {
+            runtimeController: string;
+            controller: string;
+            controllerMethod: string;
+            entity: string;
+            repository: string;
+            provider: string;
+            subscriber: string;
+        };
+    };
+    const old: {
+        HAS_TABLE_IN_DB: symbol;
+        MDC_KEY: string;
+        WEBSQL_REST_PROGRESS_FUN: symbol;
+        WEBSQL_REST_PROGRESS_FUN_START: symbol;
+        WEBSQL_REST_PROGRESS_FUN_DONE: symbol;
+        WEBSQL_REST_PROGRESS_TIMEOUT: symbol;
+        X_TOTAL_COUNT: string;
+        CIRCURAL_OBJECTS_MAP_BODY: string;
+        CIRCURAL_OBJECTS_MAP_QUERY_PARAM: string;
+        MAPPING_CONFIG_HEADER: string;
+        MAPPING_CONFIG_HEADER_BODY_PARAMS: string;
+        MAPPING_CONFIG_HEADER_QUERY_PARAMS: string;
+        ENDPOINT_META_CONFIG: string;
+        CLASS_DECORATOR_CONTEXT: string;
+        SOCKET_MSG: string;
+        ANGULAR: {
+            INPUT_NAMES: symbol;
+        };
+        ERROR_MESSAGES: {
+            CLASS_NAME_MATCH: string;
+        };
+    };
+}

package/websql/lib/ui/taon-admin-mode-configuration/models/taon-admin-mode-tabs.d.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+import { TemplateRef } from '@angular/core';
+export interface TaonAdminModeTab {
+    name: string;
+    template: TemplateRef<any>;
+}

package/websql/lib/ui/taon-admin-mode-configuration/taon-admin-control.service.d.ts

@@ -0,0 +1,18 @@
+// @ts-nocheck
+import { ApplicationRef, TemplateRef } from '@angular/core';
+import type { TaonAdminModeConfigurationComponent } from './taon-admin-mode-configuration.component';
+import * as i0 from "@angular/core";
+export declare class TaonAdminService {
+    private cdr;
+    taonAdminModeConfigurationComponent: TaonAdminModeConfigurationComponent;
+    private readonly admin;
+    /**
+     * @deprecated
+     */
+    disableScroll(): void;
+    constructor(cdr: ApplicationRef);
+    addTab(name: string, template: TemplateRef<any>): void;
+    init(taonAdminModeConfigurationComponent: TaonAdminModeConfigurationComponent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonAdminService>;
+}

package/websql/lib/ui/taon-admin-mode-configuration/taon-admin-mode-configuration.component.d.ts

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { ChangeDetectorRef, EventEmitter, OnInit } from '@angular/core';
+import { TaonAdmin } from './taon-admin.service';
+import { CdkDragEnd, Point } from '@angular/cdk/drag-drop';
+import { BreakpointsService } from 'static-columns/websql';
+import { Subject } from 'rxjs';
+import { TaonAdminModeTab } from './models/taon-admin-mode-tabs';
+import { TaonAdminService } from './taon-admin-control.service';
+import * as i0 from "@angular/core";
+export declare class TaonAdminModeConfigurationComponent implements OnInit {
+    private breakpointsService;
+    $destroy: Subject<unknown>;
+    readonly cdr: ChangeDetectorRef;
+    readonly taonAdminService: TaonAdminService;
+    readonly isDesktop: boolean;
+    tabs: TaonAdminModeTab[];
+    admin: TaonAdmin;
+    isWebSQLMode: boolean;
+    hideTaonToolsInProduction: boolean;
+    isIframe: boolean;
+    height: number;
+    openedOnce: boolean;
+    reloading: boolean;
+    showPasscode: boolean;
+    passcode: string;
+    message: string;
+    dragPositionX: number;
+    dragPositionY: number;
+    dragPositionZero: Point;
+    dragPosition: Point;
+    selectedIndex: number;
+    tabGroup: any;
+    wasOpenDraggablePopup: boolean;
+    taonAdminModeConfigurationDataChanged: EventEmitter<any>;
+    taonAdminModeConfigurationData: any;
+    get opened(): boolean;
+    set opened(v: boolean);
+    constructor(breakpointsService: BreakpointsService);
+    reloadTabs(): void;
+    ngOnInit(): Promise<void>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onResize(event: Event): void;
+    toogle(): Promise<void>;
+    toogleFullScreen(): Promise<void>;
+    resetDrag(): void;
+    moved(c: CdkDragEnd): void;
+    scrollTabs(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonAdminModeConfigurationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonAdminModeConfigurationComponent, "app-taon-admin-mode-configuration", never, { "taonAdminModeConfigurationData": { "alias": "taonAdminModeConfigurationData"; "required": false; }; }, { "taonAdminModeConfigurationDataChanged": "taonAdminModeConfigurationDataChanged"; }, never, ["*"], false, never>;
+}

package/websql/lib/ui/taon-admin-mode-configuration/taon-admin.service.d.ts

@@ -0,0 +1,25 @@
+// @ts-nocheck
+import type { TaonAdminModeConfigurationComponent } from './taon-admin-mode-configuration.component';
+import * as i0 from "@angular/core";
+export declare class TaonAdmin {
+    scrollableEnabled: boolean;
+    private constructor();
+    static get Instance(): TaonAdmin;
+    cmp: TaonAdminModeConfigurationComponent;
+    private onEditMode;
+    onEditMode$: import("rxjs").Observable<unknown>;
+    adminPanelIsOpen: boolean;
+    draggablePopupMode: boolean;
+    draggablePopupModeFullScreen: boolean;
+    /**
+     * Property used in taon
+     */ keepWebsqlDbDataAfterReload: boolean;
+    setEditMode(value: boolean): void;
+    setKeepWebsqlDbDataAfterReload(value: boolean): void;
+    enabledTabs: any[];
+    hide(): void;
+    show(): void;
+    logout(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonAdmin, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonAdmin>;
+}

package/websql/lib/validators.d.ts

@@ -0,0 +1,8 @@
+// @ts-nocheck
+import { Models } from './models';
+export declare namespace Validators {
+    const classNameVlidation: (className: any, target: Function) => any;
+    const checkIfMethodsWithReponseTYpeAlowed: (methods: Models.MethodConfig[], current: Models.MethodConfig) => void;
+    const validateClassFunctions: (controllers: any[], entities: any[], proviers: any[], repositories: any[]) => void;
+    const preventUndefinedModel: (model: any, id: any) => void;
+}

package/websql/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "taon",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": "^13.2.0",
+    "@angular/core": "^13.2.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "module": "fesm2022/taon.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2022": "./esm2022/taon.mjs",
+      "esm": "./esm2022/taon.mjs",
+      "default": "./fesm2022/taon.mjs"
+    }
+  },
+  "sideEffects": false
+}

package/websql/public-api.d.ts

@@ -0,0 +1,2 @@
+// @ts-nocheck
+export * from './lib';