routelit-client 0.0.1

package/dist/components/link.d.ts

@@ -0,0 +1,7 @@
+interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+    isExternal?: boolean;
+    text?: string;
+    replace?: boolean;
+}
+declare function Link({ text, children, id, href, replace, ...props }: LinkProps): import("react/jsx-runtime").JSX.Element;
+export default Link;

package/dist/components/markdown.d.ts

@@ -0,0 +1,6 @@
+interface MarkdownProps {
+    body: string;
+    allowUnsafeHtml?: boolean;
+}
+declare function Markdown({ body, allowUnsafeHtml }: MarkdownProps): import("react/jsx-runtime").JSX.Element;
+export default Markdown;

package/dist/components/radio.d.ts

@@ -0,0 +1,15 @@
+type RadioGroupProps = {
+    id: string;
+    label: string;
+    value: string;
+    required?: boolean;
+    flexDirection?: "row" | "col";
+    options: Array<{
+        label: string;
+        value: string;
+        caption?: string;
+        disabled?: boolean;
+    } | string>;
+};
+declare const RadioGroup: import("react").NamedExoticComponent<RadioGroupProps>;
+export default RadioGroup;

package/dist/components/select.d.ts

@@ -0,0 +1,15 @@
+interface SelectProps extends React.SelectHTMLAttributes<HTMLSelectElement> {
+    label?: string;
+    helperText?: string;
+    errorText?: string;
+    required?: boolean;
+    id: string;
+    value?: string;
+    options: Array<{
+        label: string;
+        value: string;
+        disabled?: boolean;
+    } | string>;
+}
+declare const Select: import("react").NamedExoticComponent<SelectProps>;
+export default Select;

package/dist/components/textarea.d.ts

@@ -0,0 +1,6 @@
+declare function TextareaComponent({ id, label, value, ...props }: {
+    id: string;
+    label?: string;
+} & React.TextareaHTMLAttributes<HTMLTextAreaElement>): import("react/jsx-runtime").JSX.Element;
+declare const Textarea: import("react").MemoExoticComponent<typeof TextareaComponent>;
+export default Textarea;

package/dist/core/actions.d.ts

@@ -0,0 +1,5 @@
+export declare function applyAddAction(componentsTree: RouteLitComponent[], action: AddAction): void;
+export declare function applyRemoveAction(componentsTree: RouteLitComponent[], action: RemoveAction): void;
+export declare function applyUpdateAction(componentsTree: RouteLitComponent[], action: UpdateAction): void;
+export declare function prependAddressToActions(actionResponse: ActionsResponse, address: number[]): ActionsResponse;
+export declare function applyActions(componentsTree: RouteLitComponent[], actions: Action[]): void;

package/dist/core/component-store.d.ts

@@ -0,0 +1,13 @@
+export declare class ComponentStore {
+    private listeners;
+    private componentStore;
+    private version;
+    constructor();
+    register: (name: string, component: React.ComponentType<any>) => void;
+    unregister: (name: string) => void;
+    get: (name: string) => import("react").ComponentType<any> | undefined;
+    getVersion: () => number;
+    subscribe: (listener: (v: number) => void) => () => void;
+    notifyListeners: () => void;
+    forceUpdate: () => void;
+}

package/dist/core/context.d.ts

@@ -0,0 +1,17 @@
+import { type ComponentStore } from "./component-store";
+import { type RouteLitManager } from "./manager";
+type RouteLitContextType = {
+    manager: RouteLitManager;
+    componentStore: ComponentStore;
+    parentManager?: RouteLitManager;
+};
+export declare const RouteLitContext: import("react").Context<RouteLitContextType>;
+export declare function useRouteLitContext(): RouteLitContextType;
+export declare function useDispatcher(): (event: CustomEvent<UIEventPayload>) => void;
+export declare function useDispatcherWith(id: string, type: string): (data: Record<string, unknown>) => void;
+export declare function useDispatcherWithAttr(id: string, type: string, attr: string): (value: unknown) => void;
+export declare function useFormDispatcher(id: string, type: string): (data: Record<string, unknown>) => void;
+export declare function useFormDispatcherWithAttr(id: string, type: string, attr: string): (value: unknown) => void;
+export declare function useIsLoading(): boolean;
+export declare function useError(): Error | undefined;
+export {};

package/dist/core/initializer.d.ts

@@ -0,0 +1,3 @@
+import { RouteLitManager } from "./manager";
+declare function initManager(dataElementSelector: string): RouteLitManager;
+export default initManager;

package/dist/core/manager.d.ts

@@ -0,0 +1,40 @@
+type Handler = (args: RouteLitComponent[]) => void;
+type IsLoadingHandler = (args: boolean) => void;
+type ErrorHandler = (args: Error) => void;
+interface RouteLitManagerProps {
+    componentsTree?: RouteLitComponent[];
+    fragmentId?: string;
+    parentManager?: RouteLitManager;
+    address?: number[];
+}
+export declare class RouteLitManager {
+    private listeners;
+    private isLoadingListeners;
+    private errorListeners;
+    private componentsTree?;
+    private _isLoading;
+    private _error?;
+    private fragmentId?;
+    private parentManager?;
+    private address?;
+    private lastURL?;
+    constructor(props: RouteLitManagerProps);
+    getLastURL: () => string;
+    handleEvent: (e: CustomEvent<UIEventPayload>) => Promise<void>;
+    handleError: (e: Error) => void;
+    applyActions: (actionsResp: ActionsResponse, shouldNotify?: boolean) => void;
+    initialize: () => void;
+    handlePopState: () => void;
+    terminate: () => void;
+    getComponentsTree: () => RouteLitComponent[];
+    isLoading: () => boolean;
+    getError: () => Error | undefined;
+    getAtAddress: (address: number[]) => RouteLitComponent[];
+    subscribe: (listener: Handler) => (() => void);
+    subscribeIsLoading: (listener: IsLoadingHandler) => (() => void);
+    subscribeError: (listener: ErrorHandler) => (() => void);
+    private notifyListeners;
+    private notifyIsLoading;
+    private notifyError;
+}
+export {};

package/dist/core/react-renderer.d.ts

@@ -0,0 +1,8 @@
+import { type RouteLitManager } from "./manager";
+import { type ComponentStore } from "./component-store";
+interface Props {
+    manager: RouteLitManager;
+    componentStore: ComponentStore;
+}
+declare function ReactRenderer({ manager, componentStore }: Props): import("react/jsx-runtime").JSX.Element;
+export default ReactRenderer;

package/dist/core/server-api.d.ts

@@ -0,0 +1 @@
+export declare function sendEvent(event: CustomEvent<UIEventPayload>, fragmentId?: string): Promise<ActionsResponse>;

package/dist/lib.d.ts

@@ -0,0 +1,30 @@
+import React from "react";
+import * as ReactDOM from "react-dom";
+import * as jsxRuntime from "react/jsx-runtime";
+import { ComponentStore } from "./core/component-store";
+import { useDispatcherWith, useDispatcherWithAttr, useFormDispatcherWithAttr, useFormDispatcher, useIsLoading, useError } from "./core/context";
+import { RouteLitManager } from "./core/manager";
+export interface RoutelitClientType {
+    manager: RouteLitManager;
+    componentStore: ComponentStore;
+    useDispatcherWith: typeof useDispatcherWith;
+    useDispatcherWithAttr: typeof useDispatcherWithAttr;
+    useFormDispatcherWithAttr: typeof useFormDispatcherWithAttr;
+    useFormDispatcher: typeof useFormDispatcher;
+    useIsLoading: typeof useIsLoading;
+    useError: typeof useError;
+}
+declare let manager: RouteLitManager;
+declare let componentStore: ComponentStore;
+declare global {
+    interface Window {
+        React: typeof React;
+        ReactDOM: typeof ReactDOM;
+        jsxRuntime: typeof jsxRuntime;
+        RoutelitClient?: RoutelitClientType;
+        componentStore?: ComponentStore;
+    }
+}
+export { useDispatcherWith, manager, componentStore, useDispatcherWithAttr, useIsLoading, useError, useFormDispatcherWithAttr, useFormDispatcher, };
+declare const RoutelitClient: RoutelitClientType;
+export { React, ReactDOM, jsxRuntime, RoutelitClient };