@sisense/sdk-ui-preact 1.33.0 → 2.0.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 resultObserver;
+    private params;
+    constructor(hook: Hook, contextConnectors?: ContextConnector<ContextData>[]);
+    private handleHookResult;
+    run(...params: Parameters<Hook>): void;
+    subscribe(listener: (result: ReturnType<Hook>) => void): import("./utils").Subscription;
+    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 { createHookApiFacade, DataObserver } from './utils';

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/create-hook-api-facade.d.ts

@@ -0,0 +1,31 @@
+import type { HookAdapter } from '../hook-adapter';
+import { AnyHookFunction } from '../types';
+/**
+ * Extracts the keys of an object `T` whose values are functions.
+ */
+type FunctionKeys<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+/**
+ * Extracts the names of all functions returned by a given hook.
+ *
+ * @typeParam Hook - A function that returns an object.
+ */
+type HookApiName<Hook extends AnyHookFunction> = FunctionKeys<ReturnType<Hook>>;
+/**
+ * Extracts the parameter types of a specific function (by name) returned from a given hook.
+ *
+ * @typeParam Hook - A hook function that returns an object.
+ * @typeParam Name - The key of the API method within the returned object.
+ */
+type HookApiParameters<Hook extends AnyHookFunction, Name extends HookApiName<Hook> = HookApiName<Hook>> = Parameters<ReturnType<Hook>[Name]>;
+/**
+ * Extracts the return type of a specific function (by name) returned from a given hook.
+ *
+ * @typeParam Hook - A hook function that returns an object.
+ * @typeParam Name - The key of the API method within the returned object.
+ */
+type HookApiReturnType<Hook extends AnyHookFunction, Name extends HookApiName<Hook> = HookApiName<Hook>> = ReturnType<ReturnType<Hook>[Name]>;
+export declare function createHookApiFacade<Hook extends AnyHookFunction, Name extends HookApiName<Hook>>(hookAdapter: HookAdapter<Hook>, apiName: Name, shouldReturnHookApiResult: true): (...args: HookApiParameters<Hook, Name>) => Promise<HookApiReturnType<Hook, Name>>;
+export declare function createHookApiFacade<Hook extends AnyHookFunction, Name extends HookApiName<Hook>>(hookAdapter: HookAdapter<Hook>, apiName: Name, shouldReturnHookApiResult?: false): (...args: HookApiParameters<Hook, Name>) => void;
+export {};

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,3 @@
+export * from './create-hook-api-facade';
+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<{}>;