qcobjects 2.4.107-ts → 2.4.108-ts

package/src/top.ts

@@ -0,0 +1,111 @@
+import { IComplexStorageCache, IComponent, IConfigService, IQCObjectsElement } from "types";
+import { buildComponents } from "./ComponentFactory";
+
+type QCObjects = {
+    lastCache?:IComplexStorageCache,
+    componentsStack:IComponent[],
+    Microservice:any,
+    Route:any,
+    BackendMicroservice:any,
+    QCObjectsElement:any,
+    QCObjectsShadowedElement:any,
+    Logger:any,
+    Class:any, 
+    _Crypt:any, 
+    TagElements:any, 
+    DefaultTemplateHandler:any, 
+    SourceJS:any, 
+    SourceCSS:any, 
+    ArrayList:any, 
+    ArrayCollection:any, 
+    GlobalSettings:any, 
+    GLOBAL:any, 
+    DDO:any, 
+    CacheController:any, 
+    ComplexCacheParams:any, 
+    ComplexStorageCache:any, 
+    ComponentWidget:any, 
+    asyncLoad:any, 
+    RegisterClass:any, 
+    ComponentURI:any, 
+    waitUntil:any, 
+    super:any, 
+    _DOMCreateElement:any, 
+    shortCode:any, 
+    getType:any, 
+    is_a:any, 
+    _DataStringify:any, 
+    serviceLoader:any, 
+    componentLoader:any, 
+    ObjectName:any, 
+    isQCObjects_Class:any, 
+    isQCObjects_Object:any, 
+    NamespaceRef:any, 
+    RegisterWidget:any, 
+    RegisterWidgets:any, 
+    range:any, 
+    getDocumentLayout:any, 
+    Export:any, 
+    New:any, 
+    Tag:any, 
+    Ready:any, 
+    methods:any, 
+    // eslint-disable-next-line no-unused-vars
+    set:(name:string, value:any) => void, 
+    // eslint-disable-next-line no-unused-vars
+    get:(name:string, _default?:any) => any, 
+    start:any, 
+    InheritClass:any, 
+    Processor:any, 
+    ComponentParams:any, 
+    ComponentDoneResponse:any, 
+    Component:any, 
+    CONFIG:any, 
+    ControllerParams:any, 
+    Controller:any, 
+    ViewParams:any, 
+    View:any, 
+    Service:any, 
+    JSONService:any, 
+    ConfigService:any, 
+    VO:any, 
+    EffectParams:any, 
+    Effect:any, 
+    TransitionEffect:any, 
+    TimerParams:any, 
+    Timer:any, 
+    Toggle:any, 
+    logger:any, 
+    sdk:any, 
+    global:any, 
+    ClassFactory:any, 
+    Package:any, 
+    Import:any,
+    _sdk_:any,
+    ClassesList:any[], 
+    PackagesList:any[],
+    PackagesNameList:any[],
+    ClassesNameList:any[]
+} &  typeof self   & typeof global ;
+
+export var _top: QCObjects = (
+    (typeof self !== "undefined" && self) ||
+           (typeof window !== "undefined" && window) ||
+           (typeof global !== "undefined" && global) ||
+           this
+ ) as QCObjects;
+(_top as any).lastCache = undefined;
+export let componentsStack:IComponent[] = [];
+
+export const resetTop = (_top_: QCObjects) => {
+    _top = _top_;
+};
+
+export const buildComponentsStack = () => {
+    componentsStack = buildComponents(document as unknown as IQCObjectsElement);
+};
+export let configService:IConfigService;
+export const setConfigService = (_configService:IConfigService) => {
+    _top.global.configService = _configService;
+    configService = _configService;
+};

package/src/types/global/index.d.ts

@@ -0,0 +1,597 @@
+/* eslint-disable @typescript-eslint/no-misused-new */
+ 
+import { ClientRequest } from "http";
+import { Http2SecureServer, Http2Server, Http2ServerRequest, Http2Stream } from "http2";
+import { Stream } from "stream";
+
+export interface IMicroservice {
+    domain: string;
+    basePath: string;
+    body: any;
+    stream?: Http2Stream | Stream;
+    request?: Http2ServerRequest | ClientRequest;
+}
+
+export interface IRoute {
+    name: string;
+    description?: string;
+    path: string;
+    microservice: string;
+    redirect_to?: string;
+    headers?: any;
+    responseHeaders?: any;
+    cors?: any;
+}
+
+export interface IBackendMicroservice extends IInheritClass {
+    domain: string;
+    body: IQCObjectsElement | IQCObjectsShadowedElement | HTMLElement | string | undefined;
+    basePath: string;
+    route: IRoute;
+    projectPath?: string;
+    stream?: Http2Stream | Stream;
+    request?: Http2ServerRequest | ClientRequest;
+    routeParams?: any;
+    server: Http2SecureServer | Http2Server;
+
+    new(microservice: IMicroservice): IBackendMicroservice;
+
+    cors(): void;
+    head(formData?: object | string): void;
+    get(formData?: object | string): void;
+    post(formData?: object | string): void;
+    put(formData?: object | string): void;
+    delete(formData?: object | string): void;
+    connect(formData?: object | string): void;
+    options(formData?: object | string): void;
+    trace(formData?: object | string): void;
+    patch(formData?: object | string): void;
+    finishWithBody(stream?: Http2Stream | Stream): void;
+    done(): void;
+
+}
+
+export interface IQCObjectsElement extends HTMLElement {
+    prototype: any;
+    enableServiceClass?: boolean;
+    style:CSSStyleDeclaration;
+    Cast<T>(_o: T): T;
+    render(content: string): void;
+    find(tag: string): (HTMLElement | IQCObjectsElement)[];
+    buildComponents(rebuildObjects?: boolean): any[];
+    subelements(query: string): (HTMLElement | IQCObjectsElement)[];
+    subelements(query: string): Array<any>;
+    append(_child?: any):void;
+}
+
+export interface IQCObjectsShadowedElement extends ShadowRoot{
+    prototype: any;
+    style?: any;
+    render(content: string): void;
+    find(tag: string): (HTMLElement | IQCObjectsElement)[];
+    buildComponents(rebuildObjects?: boolean): any[];
+    subelements(query: string): (ShadowRoot | HTMLElement | IQCObjectsShadowedElement | IQCObjectsElement)[];
+    subelements(query: string): any[];
+    append: (...nodes: (string | Node)[]) => void;
+    innerHTML:string;
+}
+
+export interface ILogger {
+    debugEnabled: boolean;
+    infoEnabled: boolean;
+    warnEnabled: boolean;
+    debug(message: any): string;
+    warn(message: any): string;
+    info(message: any): string;
+
+}
+export type TClass = 
+| (( className?:string,   extendsFrom?:unknown,   definition?:unknown) => IInheritClass )
+| (( className?:string,  extendsFrom?:unknown ) => IInheritClass)
+| (( className?:string, definition?:unknown ) => IInheritClass )
+| (() => IInheritClass );
+
+export interface _ICrypt {
+    last_string: string;
+    last_key: string;
+    construct: boolean;
+    _new_(o: any): void;
+    _encrypt(): string;
+    _decrypt(): string;
+    encrypt(_string_: string, key: string): string;
+    decrypt(_string_: string, key: string): string;
+}
+
+export interface I_Crypt {
+    last_string: string;
+    last_key: string;
+    construct: boolean;
+    _new_(o: any): I_Crypt;
+    _encrypt(): string;
+    _decrypt(): string;
+    encrypt(_string_: string, key: string): string; // static
+    decrypt(_string_: string, key: string): string; // static
+}
+
+export interface ITagElements extends Array<any> {
+    show(): void;
+    hide(): void;
+    effect(): void;
+    findElements(elementName: string): ITagElements;
+}
+
+export type DefaultTemplateHandlerParams = { component: IComponent, template: string };
+
+export interface IDefaultTemplateHandler {
+    template: string;
+    __definition: any;
+    new({ component, template }: DefaultTemplateHandlerParams): IDefaultTemplateHandler;
+    assign(data: any): any;
+}
+export interface ISourceJS {
+    domain: string;
+    basePath: string;
+    type: string;
+    containerTag: string;
+    url: string;
+    data: any;
+    async: boolean;
+    external: boolean;
+    set(name: string, value: any): void;
+    get(name: string): any;
+    status: boolean;
+    done(): void;
+    fail(): void;
+    rebuild(): void;
+    Cast(o: any): any;
+    _new_(properties: any): void;
+
+}
+export interface ISourceCSS {
+    domain: string;
+    basePath: string;
+    url: string;
+    data: any;
+    async: boolean;
+    external: boolean;
+    set(name: string, value: any): void;
+    get(name: string): any;
+    done(): void;
+    fail(): void;
+    rebuild(): void;
+    Cast(o: any): any;
+    _new_(properties: any): void;
+
+}
+
+export type IArrayList = Array<any>;
+export interface IArrayCollection {
+    source: IArrayList;
+    changed(prop: string, value: any): any;
+    push(value: any): void;
+    pop(value: any): void;
+    _new_(source: IArrayList): void;
+}
+export interface IGlobalSettings {
+    _GLOBAL: any;
+    set(name: string, value: any): void;
+    get(name: string, _default: any): any;
+    __start__(): Promise<any>; //static
+}
+export type IGLOBAL = IGlobalSettings;
+export type TDDOParams = {
+    instance: any,
+    name: string,
+    fget: Function,
+    fset: Function,
+    value: any
+};
+export interface IDDO {
+    new({
+        instance,
+        name,
+        fget,
+        fset,
+        value
+    }: TDDOParams): IDDO;
+}
+export type TCacheController = {
+    cache: IComplexStorageCache;
+    cachedObjectID: string;
+    cachedResponse?: any;
+}
+export type TComplexCacheParams = {
+    index: string;
+    load(cacheController?: TCacheController): any;
+    alternate(cacheController?: TCacheController): any;
+}
+export interface IComplexStorageCache {
+    object: any;
+    index: string;
+    load(cacheController: IComplexStorageCache): void;
+    alternate(cacheController: IComplexStorageCache): void;
+    clear(): void;
+    getCached(object: any): any;
+    getID(object: any): any;
+    getItem(cachedObjectID: string): JSON | null;
+    setItem(cachedObjectID: string, value: any): void;
+    isEmpty(object: any): boolean;
+    save(object: any, cachedNewResponse: string): void;
+
+    new(cache: TComplexCacheParams): IComplexStorageCache;
+
+}
+
+export type TComponentURIParams = { COMPONENTS_BASE_PATH: string, COMPONENT_NAME: string, TPLEXTENSION: string, TPL_SOURCE: string };
+export type I_ComponentWidget_ = HTMLElement;
+
+export type TasyncLoad = (callback: Function, args: Array<any>) => any;
+export type TRegisterClass = (_class_: any, namespace: string) => void;
+export type TComponentURI = ({ COMPONENTS_BASE_PATH, COMPONENT_NAME, TPLEXTENSION, TPL_SOURCE }: TComponentURIParams) => string;
+export type TwaitUntil = (func: Function, exp: Function) => void;
+export type T_super_ = (className: string, classMethodName: string, params?: Array<any>) => any;
+export type T_DOMCreateElement = (elementName: string) => IQCObjectsElement | HTMLElement;
+export type TshortCode = () => string;
+export type T__getType__ = (_class_: any) => string;
+export type Tis_a = (obj: any, typeName: string) => boolean;
+export type T_DataStringify = (data: any) => string;
+export type TserviceLoader = (service: IService, _async: boolean) => Promise<any>;
+export type TcomponentLoader = (component: IComponent, _async: boolean) => Promise<any>;
+export type TObjectName = (o: any) => string;
+export type TisQCObjects_Class = (_: any) => boolean;
+export type TisQCObjects_Object = (_: any) => boolean;
+export type TNamespaceRef = (namespace: string) => any;
+export type TRegisterWidget = (widgetName: string) => void;
+export type TRegisterWidgets = (...widgetList: string[]) => void;
+export type Trange = (start: number, stop: number, step: number) => Array<any>;
+export type TgetDocumentLayout = () => string;
+export type TExport = (fn: Function) => Function;
+export type TNew = (__class__: any, args: any) => any;
+export type TTag = (tagName: string, innerHTML?: string) => ITagElements;
+export type TReady = (e: Function) => void;
+export type T_methods_ = (_: any) => Array<any>;
+export type Tset = (_: any, _value_: any) => any;
+export type Tget = (_: any, _defaultValue_: any) => any;
+export type T__start__ = () => void;
+
+export type TBody = IQCObjectsElement | IQCObjectsShadowedElement | HTMLElement | string | null | undefined | object;
+
+export interface IInheritClass {
+    [key: string]: any;
+    __instanceID: number;
+    __classType?: string;
+    __definition?: any;
+    __new__?(o?:any): void;
+    _new_(_o_?: any):void;
+    getParentClass():any;
+    getClass():any;
+    css(_css: any): any ;
+    hierarchy(): any;
+    append(_child?: any):any;
+    attachIn(tag: any):any;
+    __namespace?: string;
+    body?: TBody;
+}
+
+export interface IProcessor extends IInheritClass {
+    component: IComponent|null;
+    processors: any;
+    process(template: string, component: IComponent): any;
+    processObject(obj: any, component?: IComponent): any;
+    setProcessor(proc: Function): any;
+    execute (component:IComponent, processorName:string, args:string):any;
+}
+
+export type TComponentParams = {
+    __parent__?: IComponent;
+    name: string;
+    template?: string;
+    templateURI?: string;
+    tplsource?: string;
+    tplextension?: string;
+    url?: string;
+    method?: string;
+    data?: any;
+    reload?: boolean;
+    shadowed?: boolean;
+    cached?: boolean;
+    enableServiceClass?:boolean| undefined;
+    assignRoutingParams?:boolean;
+    _body?: IQCObjectsElement;
+    __promise__?: Promise<any> | null;
+    __shadowRoot?: IQCObjectsShadowedElement;
+    body?: IQCObjectsElement;
+    shadowRoot?: IQCObjectsShadowedElement;
+    splashScreenComponent?: IComponent;
+    controller?: IController;
+    view?: IView;
+};
+
+
+export interface IComponent extends IInheritClass{
+    url: string;
+    cached?: boolean;
+    name: string;
+    templateURI: string;
+    tplsource: string;
+    tplextension: string;
+    template: string;
+    validRoutingWays: string[];
+    basePath: string;
+    domain: string;
+    templateHandler: string;
+    processorHandler?: IProcessor;
+    routingWay: string | null;
+    routingNodes: (IQCObjectsElement | HTMLElement)[];
+    routings: TComponentRoutings;
+    routingPath: string;
+    routingPaths: string[];
+    _componentHelpers: any[];
+    subcomponents: IComponent[];
+    splashScreenComponent?: IComponent;
+    controller?: IController | undefined;
+    routingController?: IController | undefined;
+
+    view?: IView | undefined;
+    effect?: IEffect;
+    effectClass: string;
+    method: string;
+    __promise__?: Promise<any> | null | undefined;
+    data: any;
+    shadowed?: boolean;
+    shadowRoot: IQCObjectsShadowedElement;
+    cacheIndex: string;
+    parsedAssignmentText: string;
+    serviceInstance:IService;
+    innerHTML:string;
+    reload:boolean;
+    assignRoutingParams?:boolean;
+    routingSelected: TComponentRouting[];
+    routingParams: object;
+    subtags: (HTMLElement | IQCObjectsElement | IQCObjectsShadowedElement)[];
+    bodyAttributes: any;
+    dataAttributes: any;
+    serviceData?: any;
+    container?: any;
+    serviceClassName?:string|null;
+    enableServiceClass?:boolean;
+    componentRoot?:TBody;
+    route():Promise<void>;
+    responseTo?:string;
+    __done__(): Promise<unknown>;
+    _bindroute_(): void;
+    __buildSubComponents__(rebuildObjects: boolean): IComponent[];
+    _generateRoutingPaths(componentBody: IQCObjectsElement | HTMLElement): Promise<void>;
+    _reroute_(): Promise<IComponent>;
+    route():void;
+    createServiceInstance(): Promise<JSON | string | null>;
+    createControllerInstance(): Promise<{ component: IComponent, controller: IController }>;
+    createEffectInstance(): Promise<{ component: IComponent, effect: IEffect }>;
+    createViewInstance(): Promise<{ component: IComponent, view: IView }>;
+    done(standardResponse: TComponentDoneResponse): Promise<TComponentDoneResponse>;
+    fail({ error, component }: { error: any, component: IComponent }): Promise<{ error: any; component: any; }>;
+    hostElements(tagFilter: string): (IQCObjectsElement | HTMLElement | IQCObjectsShadowedElement)[];
+    set(name: string, value: any): void;
+    get(name: string): any;
+    feedComponent(): Promise<any>;
+    rebuild(): Promise<{ request?: XMLHttpRequest, component: IComponent }>;
+    Cast(oClass: any): any;
+    fullscreen(): void;
+    closefullscreen(): void;
+    parseTemplate(template: string): string;
+    lazyLoadImages(): object | null;
+    applyTransitionEffect(effectClassName: string): void;
+    applyObserveTransitionEffect(effectClassName: string): void;
+    scrollIntoHash(): void;
+    i18n_translate(): void;
+    addComponentHelper(componentHelper: Function): void;
+    runComponentHelpers(): void;
+
+}
+
+
+export type TComponentDoneResponse = {
+    request?: XMLHttpRequest | undefined;
+    component?: IComponent ;
+};
+export type TComponentRouting = {
+    path: string, name: string, tplextension?: string
+};
+export type TComponentRoutings = TComponentRouting[];
+
+export interface ICONFIG extends IInheritClass {
+    _CONFIG_ENC: string;
+    _CONFIG: unknown;
+    set(_: string, _value_: unknown): any;
+    get(_: string, _defaultValue_?: unknown): any;
+    __definition: any;
+}
+
+export interface ICONFIG extends IInheritClass {
+    _CONFIG_ENC: string;
+    _CONFIG: unknown;
+    set(_: any, _value_: any): any;
+    get(_: any, _defaultValue_: any): any;
+    __definition: any;
+}
+
+export type TControllerParams = {
+    component: IComponent;
+    dependencies?: any[];
+};
+
+export interface IController extends IInheritClass{
+    component: IComponent ;
+    dependencies?: any[];
+    routingSelectedAttr(attrName: string): any;
+    isTouchable(): boolean;
+    onpress(subelementSelector: string, handler: EventListener): void;
+    createRoutingController(): void;
+    done(...args: any[]): void;
+    fail?(...args: any[]): void;
+}
+
+export type TViewParams = {
+    component: IComponent;
+    dependencies: Array<any>;
+};
+
+export interface IView {
+    __classType: string;
+    __definition: any;
+    __new__(): any;
+    __namespace: string;
+    body: IQCObjectsElement | HTMLElement;
+    component: IComponent;
+    new(view: TViewParams): IView;
+    done(...args: any[]): void;
+    fail(...args: any[]): void;
+}
+export type TAsyncLoadCallback = 
+  | ((component: IComponent, _async?: any) => Promise<any>)
+  | ((service: IService, _async?: any) => Promise<unknown>)
+  | ((_async?: any) => any);
+export type TServiceDoneResponse = { request: XMLHttpRequest | null, service: IService };
+export type TServiceStandardResponse = {
+    request: XMLHttpRequest | null,
+    service: IService,
+    responseHeaders:any[]
+};
+export interface IService extends IInheritClass {
+    withCredentials: boolean;
+    useHTTP2: any;
+    options: object;
+    name:string;
+    kind: string;
+    domain: string;
+    basePath: string;
+    url: string;
+    method: string;
+    data: any;
+    reload: boolean;
+    cached: boolean;
+    headers: any;
+    responseHeaders:any;
+    local({request, service}:TServiceStandardResponse):void;
+    mockup({request, service}:TServiceStandardResponse):void;
+    template: unknown;
+    set(name: string, value: any): void;
+    get(name: string): any;
+    done({ request, service }: TServiceDoneResponse): void;
+    fail(...args: any[]): void;
+}
+export interface IJSONService extends IService {
+    JSONresponse?: JSON;
+}
+export interface IConfigService extends IJSONService {
+    configFileName: string;
+    configLoaded():Promise<void>;
+}
+export type TIVO = object;
+export type TEffectParams = {
+    duration: number;
+    timing: (timeFraction: number)=> number;
+    draw: (progress: number)=> void;
+};
+
+export interface IEffect extends IInheritClass {
+    duration: number;
+    apply(...args: any[]): any;
+    done?(...args: any[]): any;
+    animate(effect: TEffectParams): void;
+}
+
+export type TTransitionEffectParams = {
+    alphaFrom?: number,
+    alphaTo?: number,
+    angleFrom?: number,
+    angleTo?: number,
+    radiusFrom?: number,
+    radiusTo?: number,
+    scaleFrom?: number,
+    scaleTo?: number
+};
+
+export interface ITransitionEffect extends IEffect {
+    component: IComponent;
+    defaultParams: TTransitionEffectParams;
+    duration: number;
+    fitToHeight: boolean;
+    fitToWidth: boolean;
+    effects: string[];
+
+}
+export type TTimerParams = {
+    duration: number;
+    timing:(timeFraction: number, elapsed?: number)=> number;
+    intervalInterceptor:(progress: number)=> void;
+};
+
+export interface ITimer extends IInheritClass {
+    duration: number;
+    alive: boolean;
+    thread(timer: TTimerParams): void;
+}
+export interface IToggle {
+    _toggle: boolean;
+    _inverse: boolean;
+    _positive: Function;
+    _negative: Function;
+    _dispatched?: boolean;
+    _args: Array<any>;
+
+    new (positive: Function, negative: Function, args: Array<any>):IToggle;
+
+}
+
+export let logger: ILogger;
+export let _sdk_: Promise<any>;
+export var global: typeof globalThis | IGLOBAL;
+
+export type TClassFactory = (className: string) => any;
+export type TPackage = (packageName: string, classesList?: Array<any> ) => Array<any> | undefined;
+export type TImport = (packageName: string, ready?: Function, external?: boolean) => any;
+
+export type T_QC_PACKAGES = { [key: string]: any };
+export type T_QC_CLASSES = { [key: string]: any };
+
+export declare const cordova: any;
+
+export declare interface Array<T> {
+    length: any;
+    prototype: any;
+    unique(): T[];
+    table(): void;
+    sum(): number;
+    avg(): number;
+    min(): number;
+    max(): number;
+    sortBy(propName: string, sortAsc?: boolean): T[];
+    matrix(length: number, fillValue?: number): T[];
+    matrix2d(length: number, fillValue?: number): T[][];
+    matrix3d(length: number, fillValue?: number): T[][][];
+}
+
+export declare interface ArrayConstructor {
+    unique<T>(a: Array<T>): T[];
+    table<T>(a: Array<T>): void;
+    sum<T>(a: Array<T>): number;
+    avg<T>(a: Array<T>): number;
+    min<T>(a: Array<T>): number;
+    max<T>(a: Array<T>): number;
+    sortBy<T>(a: Array<T>, propName: string, sortAsc?: boolean): T[];
+    matrix<T>(a: Array<T>, length: number, fillValue?: number): T[];
+    matrix2d<T>(a: Array<T>, length: number, fillValue?: number): T[][];
+    matrix3d<T>(a: Array<T>, length: number, fillValue?: number): T[][][];
+
+}
+
+export interface String {
+    prototype: any;
+    list(): string[];
+}
+
+export declare const componentsStack: IComponent[];
+export declare const lastCache: IComplexStorageCache | undefined;
+
+

package/src/uniqueID.ts

@@ -0,0 +1,3 @@
+import { shortCode } from "./shortCode";
+
+export const uniqueId = shortCode;