@sisense/sdk-ui-preact 1.32.0 → 1.34.0

package/dist/packages/sdk-ui-preact/src/component-adapter/component-adapter.d.ts

@@ -1,18 +1,16 @@
-import { type VNode } from 'preact';
 import { ContextConnector } from './context-connector';
-type ContextData = any;
-type ComponentBuilder = () => VNode;
+import type { AnyComponentFunction, ContextData } from './types';
 /** @internal */
-export declare class ComponentAdapter {
-    private componentBuilder;
+export declare class ComponentAdapter<Component extends AnyComponentFunction> {
+    private component;
     private contextConnectors;
     private rootElement;
     private contexts;
     private subscriptions;
-    constructor(componentBuilder: ComponentBuilder, contextConnectors?: ContextConnector<ContextData>[]);
+    private props;
+    constructor(component: Component, contextConnectors?: ContextConnector<ContextData>[]);
     private prepareContexts;
     private renderComponentWithContext;
-    render(rootElement: HTMLElement): void;
+    render(rootElement: HTMLElement, props: Parameters<Component>[0]): void;
     destroy(): void;
 }
-export {};

package/dist/packages/sdk-ui-preact/src/component-adapter/context-connector.d.ts

@@ -1,14 +1,8 @@
-import { type FunctionComponent, type VNode } from 'preact';
-import type { Observable } from 'rxjs';
+import { type CustomContextProviderProps } from '@sisense/sdk-ui';
+import { AnyComponentFunction } from './types';
+import { DataObserver } from './utils/data-observer';
 /** @internal */
-export type ContextConnector<T> = {
-    prepareContext: () => T | Promise<T> | Observable<T>;
-    renderContextProvider: (contextData: T, children: VNode, error?: Error) => VNode;
+export type ContextConnector<P extends CustomContextProviderProps<any>> = {
+    propsObserver: DataObserver<P>;
+    providerComponent: AnyComponentFunction<P>;
 };
-type AbstractContextProviderProps = {
-    context?: any;
-    error?: Error;
-};
-/** @internal */
-export declare function createContextProviderRenderer<T extends AbstractContextProviderProps>(provider: FunctionComponent<T>): (contextData: T['context'], children: VNode, error?: Error) => VNode<{}>;
-export {};

package/dist/packages/sdk-ui-preact/src/component-adapter/hook-adapter.d.ts

@@ -0,0 +1,15 @@
+import { ContextConnector } from './context-connector';
+import { AnyHookFunction, ContextData } from './types';
+/** @internal */
+export declare class HookAdapter<Hook extends AnyHookFunction> {
+    private hook;
+    private rootElement;
+    private componentAdapter;
+    private resultSubscribeFn;
+    private params;
+    constructor(hook: Hook, contextConnectors?: ContextConnector<ContextData>[]);
+    private handleHookResult;
+    run(...params: Parameters<Hook>): void;
+    subscribe(hookResultSubscribeFn: (result: ReturnType<Hook>) => void): void;
+    destroy(): void;
+}

package/dist/packages/sdk-ui-preact/src/component-adapter/hook-wrapper-component.d.ts

@@ -0,0 +1,18 @@
+/** @internal */
+import { AnyHookFunction } from './types';
+interface HookWrapperComponentProps<Hook extends AnyHookFunction> {
+    /**
+     * The hook to call
+     */
+    hook: Hook;
+    /**
+     * The parameters to pass to the hook
+     */
+    params: Parameters<Hook>;
+    /**
+     * The hook result callback function
+     */
+    onResult: (result: ReturnType<Hook>) => void;
+}
+export declare function HookWrapperComponent<Hook extends AnyHookFunction>({ hook, params, onResult, }: HookWrapperComponentProps<Hook>): null;
+export {};

package/dist/packages/sdk-ui-preact/src/component-adapter/index.d.ts

@@ -1,3 +1,6 @@
 export * from './component-adapter';
 export * from './context-connector';
 export * from './custom-element';
+export * from './hook-adapter';
+export type { AnyComponentFunction } from './types';
+export { DataObserver } from './utils/data-observer';

package/dist/packages/sdk-ui-preact/src/component-adapter/types.d.ts

@@ -0,0 +1,11 @@
+import { type VNode } from 'preact';
+export type ContextData = any;
+export type ComponentBuilder = () => VNode;
+export type Context = {
+    isReady: boolean;
+    data?: ContextData;
+    error?: Error;
+};
+export type AnyHookFunction = (...args: any[]) => any;
+/** @internal */
+export type AnyComponentFunction<P = any> = (props: P) => any;

package/dist/packages/sdk-ui-preact/src/component-adapter/utils/data-observer.d.ts

@@ -0,0 +1,12 @@
+import { Listener, Subscription } from './observable';
+/** @internal */
+export declare class DataObserver<T> {
+    private data;
+    private observable;
+    constructor(initialValue?: T);
+    subscribe(listener: Listener<T>, immediateTriggerLastData?: boolean): Subscription;
+    setValue(newValue: T): void;
+    getValue(): T | undefined;
+    destroy(): void;
+}
+export declare function isDataObserver<T>(object: any): object is DataObserver<T>;

package/dist/packages/sdk-ui-preact/src/component-adapter/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './data-observer';
+export * from './observable';

package/dist/packages/sdk-ui-preact/src/component-adapter/utils/observable.d.ts

@@ -0,0 +1,10 @@
+export type Listener<T> = (newValue: T) => void;
+export interface Subscription {
+    unsubscribe: () => void;
+}
+export declare class Observable<T> {
+    private listeners;
+    subscribe(listener: Listener<T>): Subscription;
+    notify(newValue: T): void;
+    destroy(): void;
+}

package/dist/packages/sdk-ui-preact/src/index.d.ts

@@ -1,3 +1,3 @@
-export * from '@sisense/sdk-ui';
-export * from './render';
 export * from './component-adapter';
+export * from './render';
+export * from '@sisense/sdk-ui';

package/dist/packages/sdk-ui-preact/src/render.d.ts

@@ -1,10 +1,10 @@
-import { type FunctionComponent, type ComponentChildren, type VNode } from 'preact';
+import { type ComponentChildren, type FunctionComponent, type VNode } from 'preact';
 /** @internal */
 export declare const preactRenderComponent: <P>(rootElement: HTMLDivElement, component: FunctionComponent<P>, componentProps: P) => void;
 /** @internal */
 export declare const createElement: <P>(component: FunctionComponent<P>, props: P, children?: ComponentChildren) => VNode;
 /** @internal */
-export declare const createWrapperElement: (nativeElement: HTMLDivElement) => VNode;
+export declare const createWrapperElement: <R = VNode<{}>>(nativeElement: HTMLDivElement) => R;
 type AnyObject = Record<string, any>;
 /** @internal */
 export declare const createWrapperElementHandler: <P extends AnyObject>(handler: (props: P) => HTMLDivElement) => (props: P) => VNode<{}>;