@tailorkit/react 0.1.0-beta.4 → 0.1.0-beta.42

package/dist/components/render.d.ts

@@ -1,19 +0,0 @@
-import type { ComponentPropsWithoutRef, ElementType, HTMLAttributes, ReactElement, ReactNode, Ref } from "react";
-type ElementProps<TTagName extends ElementType> = ComponentPropsWithoutRef<TTagName> & {
-    ref?: Ref<unknown>;
-};
-export interface RenderProps {
-    render?: ReactElement<Record<string, unknown>>;
-}
-export type ComponentProps<TTagName extends ElementType> = ElementProps<TTagName> & RenderProps;
-export declare function useRender<TTagName extends ElementType>({ defaultTagName, props, render, }: {
-    defaultTagName: TTagName;
-    props: ElementProps<TTagName>;
-    render?: ReactElement<Record<string, unknown>>;
-}): ReactNode;
-export declare function mergeProps<TProps extends Record<string, unknown>>(...propSets: (TProps | Record<string, unknown> | undefined)[]): TProps;
-export declare function composeRefs<T>(...refs: (Ref<T> | undefined)[]): Ref<T>;
-export type HtmlProps<TElement extends HTMLElement> = HTMLAttributes<TElement> & {
-    ref?: Ref<TElement>;
-};
-export {};

package/dist/components/root.d.ts

@@ -1,10 +0,0 @@
-import type { ReactNode } from "react";
-import type { TailorKitApp } from "../tailor-kit";
-import type { ComponentProps } from "./render";
-import type { RootTailor } from "./context";
-export interface RootProps extends ComponentProps<"div"> {
-    apps?: TailorKitApp[];
-    children?: ReactNode;
-    tailor: RootTailor;
-}
-export declare function Root({ apps: appsProp, children, render, tailor, ...props }: RootProps): ReactNode;

package/dist/hooks/use-current-screen.d.ts

@@ -1,23 +0,0 @@
-import type { StandardJSONSchemaV1 } from "@standard-schema/spec";
-import type { ScreenDefinition } from "@tailorkit/core/schema";
-import type { TailorKitStore } from "../tailor-kit";
-export type ScreenName<TScreens extends Record<string, ScreenDefinition>> = keyof TScreens & string;
-export type ScreenContext<TScreen> = TScreen extends ScreenDefinition<infer TContext> ? TContext extends StandardJSONSchemaV1 ? StandardJSONSchemaV1.InferOutput<TContext> : Record<string, never> : never;
-interface ReadyScreenOptions<TScreens extends Record<string, ScreenDefinition>, TScreen extends ScreenName<TScreens>> {
-    context: ScreenContext<TScreens[TScreen]>;
-    screen: TScreen;
-    status?: "ready";
-}
-interface LoadingScreenOptions<TScreen extends string> {
-    context?: never;
-    screen: TScreen;
-    status: "loading";
-}
-interface ErrorScreenOptions<TScreen extends string> {
-    context?: never;
-    screen: TScreen;
-    status: "error";
-}
-export type CurrentScreenOptions<TScreens extends Record<string, ScreenDefinition>, TScreen extends ScreenName<TScreens> = ScreenName<TScreens>> = TScreen extends ScreenName<TScreens> ? ReadyScreenOptions<TScreens, TScreen> | LoadingScreenOptions<TScreen> | ErrorScreenOptions<TScreen> : never;
-export declare function createUseCurrentScreen<TScreens extends Record<string, ScreenDefinition>>(store: TailorKitStore): <TScreen extends ScreenName<TScreens>>(options: CurrentScreenOptions<TScreens, TScreen>) => void;
-export {};

package/dist/node-store.d.ts

@@ -1,16 +0,0 @@
-import type { RemoteNode } from "@tailorkit/sandbox/protocol";
-type Listener = () => void;
-export declare class NodeStore {
-    private nodes;
-    private signatures;
-    private nodeListeners;
-    private rootListeners;
-    private rootId;
-    clear(): void;
-    setSnapshot(tree: RemoteNode): void;
-    getRootId(): string | null;
-    getNode(id: string): RemoteNode | null;
-    subscribe(id: string, listener: Listener): () => void;
-    subscribeRoot(listener: Listener): () => void;
-}
-export {};

package/dist/remote-context.d.ts

@@ -1,8 +0,0 @@
-import type { HostToWorkerPayload } from "@tailorkit/sandbox/protocol";
-import type { NodeStore } from "./node-store";
-export interface RemoteViewContext {
-    components: Record<string, unknown>;
-    dispatch: (payload: HostToWorkerPayload) => void;
-    store: NodeStore;
-}
-export declare const RemoteUIContext: import("react").Context<RemoteViewContext | null>;

package/dist/tailor-kit.d.ts

@@ -1,116 +0,0 @@
-import type { ReactNode } from "react";
-import type { TailorKitSchemaSpecType } from "@tailorkit/core/spec";
-import type { TailorKitTheme, CallbackMap, ComponentDefinition, ComponentProps, ComponentSlots, Schema, ScreenDefinition, TailorKitSchema } from "@tailorkit/core/schema";
-import type { primitives } from "./primitives";
-import { Root } from "./components";
-import type { UseAppsResult } from "./hooks/use-apps";
-import type { CurrentScreenOptions, ScreenName } from "./hooks/use-current-screen";
-type ReactComponentSlots<TComponent> = {
-    [TSlot in keyof ComponentSlots<TComponent>]: ReactNode;
-};
-type AnyComponentDefinition = ComponentDefinition<Schema | undefined, CallbackMap, readonly string[] | undefined>;
-type ComponentRenderer<TComponent extends AnyComponentDefinition> = (args: {
-    props: ComponentProps<TComponent>;
-    slots: ReactComponentSlots<TComponent>;
-}) => ReactNode;
-type ComponentRenderers<TComponents extends Record<string, AnyComponentDefinition>> = {
-    [TName in keyof TComponents]?: ComponentRenderer<TComponents[TName]>;
-};
-type CompleteComponentRenderers<TComponents extends Record<string, AnyComponentDefinition>> = {
-    [TName in keyof TComponents]-?: ComponentRenderer<TComponents[TName]>;
-};
-export interface TailorKitApp {
-    clientPath?: string;
-    description?: string;
-    id: string;
-    projectId?: string;
-    currentDeployment?: {
-        id: string;
-    } | null;
-    name?: string;
-}
-export interface TailorKitAppsSnapshot {
-    apps: TailorKitApp[];
-    error: Error | null;
-    status: "error" | "idle" | "loading" | "ready";
-}
-interface TailorKitMetaSnapshot {
-    assetsBaseUrl: string | null;
-    error: Error | null;
-    schema: TailorKitSchemaSpecType | null;
-    status: "error" | "idle" | "loading" | "ready";
-}
-export interface CurrentScreenEntry {
-    context: unknown;
-    id: symbol;
-    order: number;
-    screen: string;
-    status: "error" | "loading" | "ready";
-}
-interface AppViewBaseProps {
-    app: TailorKitApp;
-    createIframe?: () => HTMLIFrameElement;
-    fallback?: ReactNode;
-    runtimeUrl?: string | URL;
-}
-type AppViewScreenProps<TScreens extends Record<string, ScreenDefinition>, TScreen extends ScreenName<TScreens> = ScreenName<TScreens>> = [ScreenName<TScreens>] extends [never] ? {
-    context?: never;
-    screen?: never;
-    status?: never;
-} : {
-    context?: never;
-    screen?: never;
-    status?: never;
-} | CurrentScreenOptions<TScreens, TScreen>;
-export type AppViewProps<TScreens extends Record<string, ScreenDefinition>, TScreen extends ScreenName<TScreens> = ScreenName<TScreens>> = AppViewBaseProps & AppViewScreenProps<TScreens, TScreen>;
-export interface TailorKitInstance<TScreens extends Record<string, ScreenDefinition> = Record<string, never>> {
-    AppView: (props: AppViewProps<TScreens>) => ReactNode;
-    Root: (props: Omit<Parameters<typeof Root>[0], "tailor">) => ReactNode;
-    getApp: (id: string) => TailorKitApp | undefined;
-    getApps: () => TailorKitApp[];
-    useApps: () => UseAppsResult;
-    useCurrentScreen: <TScreen extends ScreenName<TScreens>>(options: CurrentScreenOptions<TScreens, TScreen>) => void;
-}
-type PrimitiveRenderers = typeof primitives;
-type CustomComponentRenderers<TComponents extends Record<string, AnyComponentDefinition>> = {
-    [TName in Exclude<keyof TComponents, keyof PrimitiveRenderers>]?: ComponentRenderer<TComponents[TName]>;
-};
-export declare function components<TComponents extends Record<string, AnyComponentDefinition>>(_schema: TailorKitSchema<TComponents, Record<string, ScreenDefinition>>, customComponents: CustomComponentRenderers<TComponents>): ComponentRenderers<TComponents>;
-interface TailorKitServerShape {
-    $internal: {
-        schema: {
-            components: Record<string, unknown>;
-            screens: Record<string, unknown>;
-        };
-    };
-}
-type ServerComponentMap<TTailor extends TailorKitServerShape> = TTailor["$internal"]["schema"]["components"];
-type ServerComponents<TTailor extends TailorKitServerShape> = {
-    [TName in keyof ServerComponentMap<TTailor>]: ServerComponentMap<TTailor>[TName] extends AnyComponentDefinition ? ServerComponentMap<TTailor>[TName] : never;
-};
-type ServerScreenMap<TTailor extends TailorKitServerShape> = TTailor["$internal"]["schema"]["screens"];
-type ServerScreens<TTailor extends TailorKitServerShape> = {
-    [TName in keyof ServerScreenMap<TTailor>]: ServerScreenMap<TTailor>[TName] extends ScreenDefinition ? ServerScreenMap<TTailor>[TName] : never;
-};
-export declare function createTailorKitClient<TTailor extends TailorKitServerShape>(options: {
-    baseUrl: string | URL;
-    components?: CompleteComponentRenderers<ServerComponents<TTailor>>;
-    theme?: TailorKitTheme;
-}): TailorKitInstance<ServerScreens<TTailor>>;
-export type TailorKitStore = ReturnType<typeof createTailorKitStore>;
-declare function createTailorKitStore(baseUrlInput: string | URL): {
-    baseUrl: URL;
-    fetchApps: (options?: {
-        force?: boolean;
-    }) => Promise<void>;
-    fetchMeta: () => Promise<void>;
-    getApp: (id: string) => TailorKitApp | undefined;
-    getApps: () => TailorKitApp[];
-    getAppsSnapshot: () => TailorKitAppsSnapshot;
-    getCurrentScreen: () => CurrentScreenEntry | null;
-    getMetaSnapshot: () => TailorKitMetaSnapshot;
-    registerScreen: (entry: Omit<CurrentScreenEntry, "order">) => void;
-    subscribe: (listener: () => void) => (() => void);
-    unregisterScreen: (id: symbol) => void;
-};
-export type { CurrentScreenOptions } from "./hooks/use-current-screen";