@jay-framework/secure 0.5.0

package/dist/index.d.ts

@@ -0,0 +1,284 @@
+import * as _jay_framework_runtime from '@jay-framework/runtime';
+import { Coordinate, JayEventHandler, JayNativeFunction, JayElement, PreRenderElement, BaseJayElement, JayComponent, JayComponentConstructor, PrivateRef, HTMLElementCollectionProxy, HTMLElementProxy, ComponentCollectionProxy, updateFunc, MountFunc, BaseReferencesManager, JayEventHandlerWrapper, ManagedRefType, ManagedRefs, PrivateRefConstructor, HTMLElementProxyTarget, HTMLElementCollectionProxyTarget, GlobalJayEvents } from '@jay-framework/runtime';
+import { JSONPatch, ArrayContexts } from '@jay-framework/json-patch';
+import * as _jay_framework_component from '@jay-framework/component';
+import { JayComponentCore } from '@jay-framework/component';
+import { Reactive } from '@jay-framework/reactive';
+
+declare enum JayPortMessageType {
+    render = 0,
+    addEventListener = 1,
+    root = 2,
+    eventInvocation = 3,
+    removeEventListener = 4,
+    nativeExec = 5,
+    nativeExecResult = 6,
+    rootApiInvoke = 7,
+    rootApiReturns = 8
+}
+interface JayPortMessage {
+    readonly type: JayPortMessageType;
+}
+interface JPMRender extends JayPortMessage {
+    readonly type: JayPortMessageType.render;
+    patch: JSONPatch;
+}
+interface JPMAddEventListener extends JayPortMessage {
+    readonly type: JayPortMessageType.addEventListener;
+    eventType: string;
+    refName: string;
+    nativeId?: string;
+}
+interface JPMNativeExec extends JayPortMessage {
+    readonly type: JayPortMessageType.nativeExec;
+    refName?: string;
+    nativeId: string;
+    correlationId: number;
+    coordinate?: Coordinate;
+}
+interface JPMNativeExecResult extends JayPortMessage {
+    readonly type: JayPortMessageType.nativeExecResult;
+    refName?: string;
+    correlationId: number;
+    result: any;
+    error: any;
+}
+interface JPMRemoveEventListener extends JayPortMessage {
+    readonly type: JayPortMessageType.removeEventListener;
+    eventType: string;
+    refName: string;
+}
+interface JPMDomEvent extends JayPortMessage {
+    readonly type: JayPortMessageType.eventInvocation;
+    eventType: string;
+    coordinate: Coordinate;
+    eventData: any;
+}
+interface JPMRootComponentViewState extends JayPortMessage {
+    readonly type: JayPortMessageType.root;
+    patch: JSONPatch;
+}
+interface JPMRootAPIInvoke extends JayPortMessage {
+    readonly type: JayPortMessageType.rootApiInvoke;
+    apiName: string;
+    callId: number;
+    params: Array<any>;
+}
+interface JPMRootAPIReturns extends JayPortMessage {
+    readonly type: JayPortMessageType.rootApiReturns;
+    callId: number;
+    returns: any;
+    error?: any;
+}
+
+type JPMMessage = JPMRootComponentViewState | JPMRender | JPMAddEventListener | JPMDomEvent | JPMNativeExecResult | JPMNativeExec | JPMRootAPIInvoke | JPMRootAPIReturns | JPMRemoveEventListener;
+type JayPortInMessageHandler = (inMessage: JPMMessage) => void;
+interface JayChannel {
+    postMessages(messages: Array<[number, JPMMessage]>, newCompIdMessages: Array<[string, number]>): any;
+    onMessages(handler: (messages: Array<[number, JPMMessage]>, newCompIdMessages: Array<[string, number]>) => void): any;
+}
+interface IJayPort {
+    getRootEndpoint(): IJayEndpoint;
+    getEndpoint(parentCompId: number, parentCoordinate: Coordinate): IJayEndpoint;
+    batch<T>(handler: () => T): T;
+    flush(): any;
+}
+interface IJayEndpoint {
+    port: IJayPort;
+    post(outMessage: JPMMessage): any;
+    onUpdate(handler: JayPortInMessageHandler): any;
+    readonly compId: number;
+}
+declare function setMainPort(port: IJayPort): void;
+declare function useMainPort(): IJayPort;
+declare function setWorkerPort(port: IJayPort): void;
+declare function useWorkerPort(): IJayPort;
+
+interface JayPortLogger {
+    logPost(compId: number, message: JPMMessage): void;
+    logInvoke(compId: number, message: JPMMessage, endpointFound: boolean): void;
+}
+declare class JayPortLoggerConsole implements JayPortLogger {
+    logPost(compId: number, message: JPMMessage): void;
+    logInvoke(compId: number, message: JPMMessage, endpointFound: boolean): void;
+}
+
+declare class JayPort implements IJayPort {
+    private channel;
+    private logger?;
+    private messages;
+    private endpoints;
+    private futureEndpointMessages;
+    private inBatch;
+    private comps;
+    private lastCompId;
+    private newCompIdMessages;
+    private isAutoFlushScheduled;
+    private autoFlushTimeout;
+    constructor(channel: JayChannel, logger?: JayPortLogger);
+    private getCompId;
+    getEndpoint(parentCompId: number, parentCoordinate: Coordinate): IJayEndpoint;
+    getRootEndpoint(): IJayEndpoint;
+    post(compId: number, outMessage: JPMMessage): void;
+    batch<T>(handler: () => T): T;
+    invoke(messages: Array<[number, JPMMessage]>, newCompIdMessages: Array<[string, number]>): void;
+    flush(): void;
+    private scheduleFlush;
+}
+declare class JayEndpoint implements IJayEndpoint {
+    readonly compId: number;
+    readonly port: JayPort;
+    private handler;
+    private initMessages;
+    constructor(compId: number, port: JayPort);
+    post(outMessage: JPMMessage): void;
+    onUpdate(handler: JayPortInMessageHandler): void;
+    invoke(inMessage: JPMMessage): void;
+    setInitMessages(initMessages: JPMMessage[]): void;
+}
+
+interface WorkerSelf {
+    postMessage(message: any): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+}
+declare class HandshakeMessageJayChannel implements JayChannel {
+    private handler;
+    private worker;
+    private handshakeComplete;
+    private pendingMessages;
+    constructor(worker: Worker | WorkerSelf);
+    workerOnMessage: (ev: MessageEvent) => void;
+    onMessages(handler: (messages: Array<[number, JPMMessage]>, newCompIdMessages: Array<[string, number]>) => void): void;
+    postMessages(messages: Array<[number, JPMMessage]>, newCompIdMessages: Array<[string, number]>): void;
+}
+
+type FunctionsRepository = Record<string, JayEventHandler<Event, any, any> | JayNativeFunction<any, any, any>>;
+type JayNativeFunction$<ElementType extends HTMLElement, ViewState, ResultType> = JayNativeFunction<ElementType, ViewState, ResultType> & {
+    id: string;
+};
+type JayGlobalNativeFunction<R> = () => Promise<R> | R;
+type JayGlobalNativeFunction$<R> = JayGlobalNativeFunction<R> & {
+    id: string;
+};
+
+interface CompBridgeOptions {
+    events?: Array<string>;
+    functions?: Array<string>;
+    funcRepository?: FunctionsRepository;
+}
+declare function makeJayComponentBridge<PropsT extends object, ViewState extends object, Refs extends object, JayElementT extends JayElement<ViewState, Refs>>(render: PreRenderElement<ViewState, Refs, JayElementT>, options?: CompBridgeOptions): (props: PropsT) => _jay_framework_component.ConcreteJayComponent<object, ViewState, Refs, JayComponentCore<object, ViewState>, JayElementT>;
+
+interface SecureCoordinateContext {
+    coordinate: Coordinate;
+}
+declare const SECURE_COORDINATE_MARKER: _jay_framework_runtime.ContextMarker<SecureCoordinateContext>;
+declare function secureChildComp<ParentVS, Props, ChildT, ChildElement extends BaseJayElement<ChildT>, ChildComp extends JayComponent<Props, ChildT, ChildElement>>(compCreator: JayComponentConstructor<Props>, getProps: (t: ParentVS) => Props, ref: PrivateRef<ParentVS, ChildComp>): BaseJayElement<ParentVS>;
+
+declare function mainRoot<ViewState>(viewState: ViewState, elementConstructor: () => BaseJayElement<ViewState>, funcRepository?: FunctionsRepository): BaseJayElement<ViewState>;
+
+type Refs = Record<string, HTMLElementCollectionProxy<any, any> | HTMLElementProxy<any, any> | JayComponent<any, any, any> | ComponentCollectionProxy<any, JayComponent<any, any, any>>>;
+
+interface SandboxElement<ViewState> {
+    update: updateFunc<ViewState>;
+    mount: MountFunc;
+    unmount: MountFunc;
+}
+declare function sandboxElement<ViewState>(ref: SecureElementRef<any, any>): SandboxElement<ViewState>;
+declare function sandboxChildComp<ParentVS, Props, ChildT, ChildElement extends BaseJayElement<ChildT>, ChildComp extends JayComponent<Props, ChildT, ChildElement>>(compCreator: JayComponentConstructor<Props>, getProps: (t: ParentVS) => Props, ref: PrivateRef<ParentVS, ChildComp>): SandboxElement<ParentVS>;
+declare function sandboxForEach<ParentViewState, ItemViewState extends object>(getItems: (viewState: ParentViewState) => ItemViewState[], matchBy: string, children: () => SandboxElement<ItemViewState>[]): SandboxElement<ParentViewState>;
+declare function sandboxCondition<ViewState>(condition: (newData: ViewState) => boolean, children: SandboxElement<ViewState>[]): SandboxElement<ViewState>;
+
+interface SandboxBridgeElement<ViewState> {
+    update: updateFunc<ViewState>;
+    mount: MountFunc;
+    unmount: MountFunc;
+    refs: Refs;
+}
+interface RefImplementation<ViewState> {
+    addEventListener<E extends Event>(type: string, listener: JayEventHandler<E, any, any>, options?: boolean | AddEventListenerOptions, nativeId?: string): void;
+    removeEventListener<E extends Event>(type: string, listener: JayEventHandler<E, any, any>, options?: EventListenerOptions | boolean): void;
+    invoke: (type: string, coordinate: Coordinate, eventData?: any) => void;
+}
+interface SecureElementRef<ViewState, PublicRefAPI> {
+    update: updateFunc<ViewState>;
+    mount: MountFunc;
+    unmount: MountFunc;
+}
+declare class SecureReferencesManager extends BaseReferencesManager {
+    private ep;
+    readonly eventWrapper: JayEventHandlerWrapper<any, any, any>;
+    constructor(ep: IJayEndpoint, eventWrapper: JayEventHandlerWrapper<any, any, any>);
+    mkManagedRef(refType: ManagedRefType, refName: string): ManagedRefs;
+    currentContext(): {
+        currData: any;
+        coordinate: (refName: string) => Coordinate;
+    };
+    static for(endpoint: IJayEndpoint, eventWrapper: JayEventHandlerWrapper<any, any, any>, elem: string[], elemCollection: string[], comp: string[], compCollection: string[], childRefManagers?: Record<string, SecureReferencesManager>): [SecureReferencesManager, PrivateRefConstructor<any>[]];
+    static forElement(elem: string[], elemCollection: string[], comp: string[], compCollection: string[], childRefManagers?: Record<string, SecureReferencesManager>): [SecureReferencesManager, PrivateRefConstructor<any>[]];
+    static forSandboxRoot(elem: string[], elemCollection: string[], comp: string[], compCollection: string[], childRefManagers?: Record<string, SecureReferencesManager>): [SecureReferencesManager, PrivateRefConstructor<any>[]];
+}
+declare abstract class SecurePrivateRefs<ViewState, ElementType extends HTMLElement> implements RefImplementation<ViewState> {
+    protected ref: string;
+    protected ep: IJayEndpoint;
+    listeners: Map<string, JayEventHandler<any, any, any>>;
+    items: Map<string, SecureHTMLElementRefImpl<ViewState, ElementType>>;
+    constructor(ref: string, ep: IJayEndpoint);
+    addEventListener<E extends Event>(type: string, listener: JayEventHandler<E, ViewState, any> | null, options?: boolean | AddEventListenerOptions, nativeId?: string): void;
+    removeEventListener<E extends Event>(type: string, listener: JayEventHandler<E, ViewState, any> | null, options?: EventListenerOptions | boolean): void;
+    invoke: (type: string, coordinate: Coordinate, eventData?: any) => void;
+    addRef(ref: SecureHTMLElementRefImpl<ViewState, ElementType>): void;
+    removeRef(ref: SecureHTMLElementRefImpl<ViewState, ElementType>): void;
+}
+declare class SecureHTMLElementRefImpl<ViewState, ElementType extends HTMLElement> implements SecureElementRef<ViewState, HTMLElementProxy<ViewState, ElementType>>, HTMLElementProxyTarget<ViewState, ElementType>, RefImplementation<ViewState> {
+    private ref;
+    private ep;
+    viewState: ViewState;
+    readonly coordinate: Coordinate;
+    private parentCollection?;
+    listeners: Map<string, JayEventHandler<any, any, any>>;
+    constructor(ref: string, ep: IJayEndpoint, viewState: ViewState, coordinate: Coordinate, parentCollection?: SecurePrivateRefs<ViewState, ElementType>);
+    addEventListener<E extends Event>(type: string, listener: JayEventHandler<E, any, any>, options?: boolean | AddEventListenerOptions, nativeId?: string): void;
+    removeEventListener<E extends Event>(type: string, listener: JayEventHandler<E, any, any>, options?: EventListenerOptions | boolean): void;
+    invoke: (type: string, coordinate: Coordinate, eventData?: any) => void;
+    exec$<ResultType>(handler: JayNativeFunction<any, any, ResultType>): Promise<ResultType>;
+    update: (newViewState: ViewState) => void;
+    mount(): void;
+    unmount(): void;
+    getPublicAPI(): HTMLElementProxy<ViewState, ElementType>;
+}
+declare class SecureHTMLElementRefsImpl<ViewState, ElementType extends HTMLElement> extends SecurePrivateRefs<ViewState, ElementType> implements HTMLElementProxyTarget<ViewState, ElementType>, RefImplementation<ViewState>, ManagedRefs {
+    mkManagedRef(currData: any, coordinate: Coordinate, eventWrapper: JayEventHandlerWrapper<any, any, any>): SecureHTMLElementRefImpl<ViewState, ElementType>;
+    getPublicAPI(): HTMLElementProxy<ViewState, ElementType>;
+    exec$<T>(handler: (elem: ElementType, viewState: ViewState) => T): Promise<T>;
+}
+declare class SecureHTMLElementCollectionRefsImpl<ViewState, ElementType extends HTMLElement> extends SecurePrivateRefs<ViewState, ElementType> implements HTMLElementCollectionProxyTarget<ViewState, ElementType>, RefImplementation<ViewState>, ManagedRefs {
+    mkManagedRef(currData: any, coordinate: Coordinate, eventWrapper: JayEventHandlerWrapper<any, any, any>): SecureHTMLElementRefImpl<ViewState, ElementType>;
+    getPublicAPI(): HTMLElementCollectionProxy<ViewState, ElementType>;
+    find(predicate: (t: ViewState, c: Coordinate) => boolean): HTMLElementProxy<ViewState, ElementType> | undefined;
+    map<ResultType>(handler: (element: HTMLElementProxy<ViewState, ElementType>, viewState: ViewState, coordinate: Coordinate) => ResultType): Array<ResultType>;
+}
+declare function newSecureHTMLElementPublicApiProxy<ViewState, ElementType extends HTMLElement, Target extends SecureHTMLElementRefImpl<ViewState, ElementType> | SecureHTMLElementRefsImpl<ViewState, ElementType> | SecureHTMLElementCollectionRefsImpl<ViewState, ElementType>>(ref: Target): Target & GlobalJayEvents<ViewState>;
+declare function mkBridgeElement<ViewState>(viewState: ViewState, sandboxElements: () => SandboxElement<ViewState>[], endpoint: IJayEndpoint, reactive: Reactive, refManager: SecureReferencesManager, getComponentInstance: () => JayComponent<any, any, any>, arraySerializationContext: ArrayContexts): SandboxBridgeElement<ViewState>;
+
+declare function elementBridge<ElementViewState, ElementRef>(viewState: ElementViewState, refManager: SecureReferencesManager, sandboxElements: () => SandboxElement<ElementViewState>[], arraySerializationContext?: ArrayContexts): JayElement<ElementViewState, ElementRef>;
+
+declare function sandboxRoot<ViewState extends object>(sandboxElements: () => Array<SandboxElement<ViewState>>): void;
+
+type NativeIdMarker = {
+    (): void;
+    id: number;
+};
+declare function handler$<EventType, ViewState, Returns>(id: string): JayEventHandler<EventType, ViewState, Returns>;
+declare function func$<ElementType extends HTMLElement, ViewState, ResultType>(id: string): JayNativeFunction<ElementType, ViewState, ResultType>;
+declare function funcGlobal$<R>(id: string): JayGlobalNativeFunction<R>;
+declare function correlatedPromise<T>(): {
+    correlationId: number;
+    execPromise$: Promise<T>;
+    resolve: (t: T) => void;
+    reject: (R: any) => void;
+};
+declare function completeCorrelatedPromise(message: JPMNativeExecResult): void;
+
+declare function exec$<R>(handler: JayGlobalNativeFunction<R>): Promise<R>;
+
+export { type FunctionsRepository, HandshakeMessageJayChannel, type IJayEndpoint, type IJayPort, type JPMMessage, type JayChannel, JayEndpoint, type JayGlobalNativeFunction, type JayGlobalNativeFunction$, type JayNativeFunction$, JayPort, type JayPortInMessageHandler, type JayPortLogger, JayPortLoggerConsole, type NativeIdMarker, SECURE_COORDINATE_MARKER, type SandboxBridgeElement, type SandboxElement, type SecureCoordinateContext, type SecureElementRef, SecureHTMLElementCollectionRefsImpl, SecureHTMLElementRefImpl, SecurePrivateRefs, SecureReferencesManager, completeCorrelatedPromise, correlatedPromise, elementBridge, exec$, func$, funcGlobal$, handler$, mainRoot, makeJayComponentBridge, mkBridgeElement, newSecureHTMLElementPublicApiProxy, sandboxChildComp, sandboxCondition, sandboxElement, sandboxForEach, sandboxRoot, secureChildComp, setMainPort, setWorkerPort, useMainPort, useWorkerPort };