ouider 0.0.2 → 0.0.3

package/dist/index.d.cts

@@ -0,0 +1,399 @@
+declare class Emits<O extends Record<string, any>> {
+    private events;
+    constructor(events: O);
+    emit(event: keyof O, ...args: any): void;
+}
+
+type StateWatcher<T> = <K extends keyof T>(key: K, oldValue: T[K], newValue: T[K]) => void;
+declare class Stated<T> {
+    value: T;
+    constructor(value: T);
+}
+declare function isStated<T>(ob: any): ob is Stated<T>;
+declare function stated<S extends Record<string, string>, T>(target: T, state: State<S>): Stated<T>;
+declare class State<T extends Record<string, any>> {
+    private THRESHOLD_TIME;
+    private debounceTime;
+    private state;
+    private listeners;
+    private timer;
+    constructor(data: T);
+    wrap<T>(obj: T): Stated<T>;
+    has(key: keyof T): boolean;
+    setValue(key: keyof T, value: any): void;
+    getValue(key: keyof T): any;
+    get value(): T;
+    private dispatchChanges;
+    didChange(path: keyof T, oldValue: any, newValue: any): Promise<void>;
+    watch(listener: StateWatcher<T>): number;
+    unwatch(listener: StateWatcher<T> | number): void;
+}
+
+type ComponentProps<K extends Record<string, any>> = K;
+/**
+ * Component decorator, it allow an auto registration of components
+ * @param options
+ * @returns
+ */
+declare function Component(options: {
+    template: string;
+    tag: string;
+    use?: OComponentType[];
+    css?: string;
+}): <T extends {
+    new (...args: any[]): {};
+}>(constructor: T) => {
+    new (...args: any[]): {
+        template: string;
+        css: string | undefined;
+        hash: string;
+    };
+} & T;
+interface Component<P extends Record<string, any>, O extends Record<string, any>> {
+    state: State<any>;
+    readonly emits: Emits<O>;
+    readonly props: ComponentProps<P>;
+    onMounted(): void;
+    willMount(): void;
+    willUnmount(): void;
+    provide<T>(key: string, value: T): void;
+    inject<T>(key: string): T | undefined;
+}
+interface ComponentConstructor<P extends Record<string, any>, O extends Record<string, any>> {
+    new (props?: P, emits?: O): Component<P, O>;
+}
+declare function createComponent<P extends Record<string, any>, O extends Record<string, any>>(ctr: ComponentConstructor<P, O>, props?: P, emits?: O): Component<P, O>;
+declare class OComponent<P extends Record<string, any> = {}, O extends Record<string, any> = {}> implements Component<P, O> {
+    state: State<any>;
+    private parent?;
+    readonly emits: Emits<O>;
+    readonly props: ComponentProps<P>;
+    private provides;
+    constructor(props?: P, emits?: O);
+    onMounted(): void;
+    willMount(): void;
+    willUnmount(): void;
+    /** Provide a value for descendants */
+    provide<T>(key: string, value: T): void;
+    /** Inject a value from nearest ancestor */
+    inject<T>(key: string): T | undefined;
+}
+type LazyLoader<P extends Record<string, any>, O extends Record<string, any>> = () => Promise<{
+    default: ComponentConstructor<P, O>;
+}>;
+type OComponentType<P extends Record<string, any> = {}, O extends Record<string, any> = {}> = ComponentConstructor<P, O> | LazyLoader<P, O>;
+
+type ProvideFunction<T> = () => T;
+type Provider<T = any> = {
+    value?: T;
+    provide?: ProvideFunction<T>;
+};
+interface Plugin {
+    install(app: App): void;
+}
+/** Injection token key */
+type InjectionKey = string;
+/** Providers type */
+type Providers = Map<InjectionKey, Provider>;
+/**
+ * OUIDesigner App
+ */
+declare class App {
+    private root;
+    private options?;
+    static currentApp: App | null;
+    private providers;
+    /**
+     * Provide a value through a key to all the app globally
+     * @param token the registration key
+     * @param value the provider value
+     */
+    provide<T>(token: InjectionKey, value: T | (() => T)): void;
+    /**
+     * Get globally a provider through a given key
+     * @param token the key to look up globally
+     * @returns a provider value
+     */
+    inject<T>(token: InjectionKey): T | undefined;
+    /**
+     * Register a plugin to be used by this app
+     * @param plugin the plugin to register
+     * @returns `this` App instance
+     */
+    use(plugin: Plugin): this;
+    constructor(root: ComponentConstructor<any, any>, options?: {
+        css?: string;
+    } | undefined);
+    /**
+     * Mount the App in a host element
+     * @param selector the host element where the app's root component should be mounted
+     */
+    mount(selector: string): Promise<void>;
+}
+/**
+ * Provide a value through a key to all the app globally
+ * @param token the registration key
+ * @param value the provider value
+ */
+declare function provide<T>(token: InjectionKey, value: T | (() => T)): void;
+/**
+ * Get globally a provider through a given key
+ * @param token the key to look up globally
+ * @returns a provider value
+ */
+declare function inject<T>(token: InjectionKey): T | undefined;
+
+type QueryFilter = "children" | "classes" | "style" | "attributes";
+declare namespace ODOM {
+    export type NodeType = 'Element' | 'Text' | 'Comment' | 'Attribute' | 'Unknown';
+    type Attributes = {
+        name: string;
+        value: string;
+    }[];
+    export class OObject {
+        uid: string;
+        tag: string;
+        constructor(uid: string, tag: string);
+        addEventListener(event: string, callback: (...args: any[]) => void): Promise<string>;
+        dettachEventListener(event: string, cbId: string): Promise<void>;
+        invoke(fn: string, ...args: any[]): Promise<void>;
+        getProperty<T>(name: string): Promise<T | null>;
+        setProperty<T>(name: string, value: T): Promise<void>;
+        dispatchEvent(eventName: string, eventClass?: string, initDict?: any): Promise<void>;
+    }
+    export abstract class ONode extends OObject {
+        textContent?: string | null;
+        type: NodeType;
+        attributes: Attributes;
+        children?: ONode[];
+        classes?: string[];
+        style?: string;
+        constructor(node: ONode);
+    }
+    export class OElement extends ONode {
+        constructor(node: ONode);
+        addClass(name: string): Promise<void>;
+        setAttribute(name: string, value: string): Promise<void>;
+        removeAttribute(name: string): Promise<void>;
+        appendChild(child: ONode): Promise<void>;
+        set innerHTML(value: string);
+        cloneNode(state: boolean): Promise<OElement | null>;
+        remove(): Promise<void>;
+        removeChild(child: ONode): Promise<void>;
+        replaceChildNode(node: ONode, child: ONode): Promise<void>;
+        replaceWith(node: ONode): Promise<void>;
+        after(node: ONode): Promise<void>;
+        setHTML(html: string): Promise<void>;
+        HTML(): Promise<string>;
+        setInnerText(text: string): Promise<void>;
+        setContentText(text: string): Promise<void>;
+        getContentText(): Promise<string>;
+        content(): Promise<string>;
+        childNodes(): Promise<OElement[]>;
+        hasAttribute(name: string): boolean;
+        getAttribute(name: string): Promise<string>;
+        attribute(name: string): string | null;
+        getAttributeNames(): Promise<string[]>;
+        parentNode(): Promise<OElement | null>;
+        insertBefore(element: ONode, node: ONode): Promise<unknown>;
+        setInputValue(value: string): Promise<void>;
+        inputValue(value: string): Promise<string>;
+        query(selector: string, filter?: QueryFilter[]): Promise<OElement | null>;
+        queryAll(selector: string, filter?: QueryFilter[]): Promise<OElement[] | null>;
+        release(): Promise<void>;
+    }
+    export {  };
+}
+declare function Native(): (clazz: any, fnName: string, descriptor: {
+    value: Function;
+} | Record<string, any>) => void;
+interface OUIDBridgeInterface {
+    invoke(name: string): Promise<any>;
+    emit(event: string, data: any): void;
+    subscribe(event: string, callback: (id: string, data: string) => void): void;
+}
+type OUIDConfig = {
+    appId: string;
+    appName: string;
+    appSecret: string;
+};
+declare var WebOUID: {
+    invoke: (id: string, name: string, argsJson: string) => void;
+} | undefined;
+declare class OUIDBridge implements OUIDBridgeInterface {
+    private callbacks;
+    private DOM_EVENT_LISTENERS;
+    private timers;
+    private _config?;
+    private listeners;
+    constructor();
+    config(conf?: OUIDConfig): OUIDBridge;
+    invoke(name: string, ...args: any[]): Promise<any>;
+    /**
+     * Make a synchronous class
+     * @param name the name without '_oui' prefix
+     * @param args the arguments list
+     * @returns a promise of T
+     */
+    call<T>(name: string, ...args: any[]): Promise<T | null>;
+    emit(event: string, data: any): void;
+    /**
+     *
+     * @param event Create a subscription for a given event name, should be possible to register only once ??
+     * @param callback
+     */
+    subscribe(event: string, callback: (id: string, ...args: any[]) => void): void;
+    query(selector: string, filter?: QueryFilter[], nodeId?: string): Promise<ODOM.OElement | null>;
+    queryAll(selector: string, filter?: QueryFilter[], nodeId?: string): Promise<ODOM.OElement[] | null>;
+    createdElement(tag: string, props?: Record<string, string>): Promise<ODOM.OElement | null>;
+    createComment(data: string): Promise<ODOM.OElement | null>;
+    addEventListener(node: ODOM.OObject | 'window' | 'document', event: string, callback: (...args: any[]) => void): Promise<string>;
+    dettachEventListener(node: ODOM.OObject | 'window' | 'document', event: string, cbId: string): Promise<void>;
+    injectComponentStyles(css: string): Promise<ODOM.OElement | null>;
+    rejectComponentStyles(cssNode: ODOM.ONode): Promise<void>;
+    getOObject(id: string): Promise<ODOM.OObject | null>;
+    acquireObject(name: string): Promise<ODOM.OObject | null>;
+    setTimeout(callback: () => void, delay: number): Promise<number>;
+    clearTimeout(id: number): Promise<void>;
+    setInterval(callback: () => void, delay: number): Promise<number>;
+    clearInterval(id: number): Promise<void>;
+}
+declare const OUID: OUIDBridge;
+declare global {
+    var OUID: OUIDBridge;
+}
+
+declare class RenderContext {
+    private app;
+    component: OComponent<Record<string, any>, Record<string, any>>;
+    private parentContext;
+    static PROVIDE_TOKEN: string;
+    private bindings;
+    private directives;
+    private mountedComponents;
+    stack: Record<string, any>[];
+    constructor(app: App, component: OComponent<Record<string, any>, Record<string, any>>, parentContext: RenderContext | null, ...frames: Record<string, any>[]);
+    get hostElement(): ODOM.OElement;
+    bind(binding: Binding): void;
+    directive(directive: Directive): void;
+    evaluateExpression(expr: string | null | undefined): boolean;
+    resolve(key: string | null | undefined, strict?: boolean, ...additionFrames: Record<string, any>[]): any;
+    /**
+     * Handing (o-model) like (ngModel) update, we should support mutliple syntaxe like o-mode="value" where value is defined directly on the component
+     * o-model="data['key']" where data is either defined on the component, of in the enclosing scope in case of for-loop for instance
+     * */
+    updateValue(key: string, value: any): void;
+    push(frame: Record<string, any>): void;
+    pop(): void;
+    updateBindings(): Promise<void>;
+    updateBinding(binding: Binding): Promise<void>;
+    updateDirectives(): Promise<void>;
+    private render;
+    private expandClass;
+    private expandStyle;
+    private expandStandardAttributes;
+    handleElementNode(node: ODOM.OElement): Promise<void>;
+    handleTextNode(node: ODOM.OElement): void;
+    private componentAttributes;
+    mountComponent<T extends Record<string, any>, O extends Record<string, string>>(hostNode: ODOM.OElement, component: OComponentType<T, O>, parentContext: RenderContext | null, props?: Record<string, {
+        name: string;
+        value: any;
+        expr?: string;
+    }>, emits?: O): Promise<void>;
+    unmountComponent(node: ODOM.OElement): Promise<void>;
+}
+type Binding = {
+    type: 'model' | 'interpolation' | 'attribute' | 'prop';
+    node: ODOM.OElement;
+    key: string;
+    template?: string | null;
+    context: RenderContext;
+};
+type Directive = {
+    type: 'if' | 'for';
+    node: ODOM.OElement;
+    expr?: string;
+    placeholder: ODOM.OElement;
+    context: RenderContext;
+    active?: boolean;
+    list?: string;
+    item?: string;
+    children?: Map<any, {
+        node: ODOM.ONode;
+        ctx: RenderContext;
+    }>;
+    key?: string;
+};
+declare function o<P extends Record<string, any>, O extends Record<string, any>>(component: ComponentConstructor<P, O>, props: P, emits?: O): OComponent<P>;
+declare function o<P extends Record<string, any>, O extends Record<string, any>>(component: OComponentType<P, O>, props: P, emits?: O): Promise<OComponent<P>>;
+
+/**
+ * Component responsible for display routes
+ * Usage: <o-router></o-router>
+ */
+declare class RouterComponent extends OComponent {
+    private routeStateHander;
+    private router;
+    willMount(): void;
+    onMounted(): void;
+    willUnmount(): void;
+}
+declare const ROUTER_INJECTION_TOKEN = "OROUTER_TOKEN";
+declare const ACTIVE_ROUTE_TOKEN = "ACTIVE_ROUTE";
+interface Route {
+    path: string;
+    name: string;
+    component?: OComponentType<any, any>;
+    redirectTo?: string;
+}
+declare function useRouter(): Router | undefined;
+declare function createRouter(routes: Routes): Router;
+type Routes = Array<Route>;
+type MatchedRoute = {
+    route: Route;
+    params: Record<string, any>;
+    query: Record<string, string>;
+};
+type Promised<T> = T | Promise<T>;
+type RouteLocationNamed = {
+    name: string;
+    params?: Record<string, any>;
+};
+type RouteGuardReturn = void | boolean | RouteLocationNamed;
+type RouteGaurdFunction = (to: {
+    url: string;
+    path: string;
+    name: string;
+}, from?: {
+    query: Record<string, string>;
+    params: Record<string, string>;
+}) => Promised<RouteGuardReturn>;
+interface RouteGuard {
+    type: 'before' | 'after';
+    fn: RouteGaurdFunction;
+}
+declare class Router implements Plugin {
+    routes: Routes;
+    private windowObject;
+    private guards;
+    private eventRegistration;
+    constructor(routes: Routes);
+    install(app: App): void;
+    resolve(path: string): MatchedRoute | null;
+    push(options: {
+        name?: string;
+        path?: string;
+        params?: Record<string, string>;
+        absolute?: boolean;
+    }): void;
+    private beforeRouteGoing;
+    private afterRouteGoing;
+    bind(component: RouterComponent): Promise<(() => void)>;
+    unbind(handler: () => void): void;
+    beforeEach(fn: RouteGaurdFunction): (() => void);
+    afterEach(fn: RouteGaurdFunction): (() => void);
+}
+
+declare function components(): Record<string, OComponent<any, any>>;
+
+export { ACTIVE_ROUTE_TOKEN, App, type Binding, Component, type ComponentConstructor, type ComponentProps, type Directive, Emits, type InjectionKey, type LazyLoader, Native, OComponent, type OComponentType, ODOM, OUID, OUIDBridge, type OUIDBridgeInterface, type OUIDConfig, type Plugin, type Promised, type Provider, type Providers, ROUTER_INJECTION_TOKEN, RenderContext, type Route, type RouteGaurdFunction, type RouteGuard, type RouteGuardReturn, type RouteLocationNamed, Router, RouterComponent, type Routes, State, type StateWatcher, Stated, WebOUID, components, createComponent, createRouter, inject, isStated, o, provide, stated, useRouter };