@superblocksteam/library 2.0.32 → 2.0.33-next.1

package/dist-types/lib/internal-details/lib/iframe.d.ts

@@ -0,0 +1,44 @@
+import type { FromChildToParentMessageTypes, FromChildToParentMessageTypesMap, FromParentToChildMessageTypes, FromParentToChildMessageTypesMap } from "./types.js";
+import type { PayloadAction } from "@superblocksteam/library-shared/types";
+export declare function isEmbeddedBySuperblocksFirstParty(): boolean;
+/** @deprecated Use editorBridge instead */
+export declare function sendMessageImmediately<MT extends FromChildToParentMessageTypes>(message: {
+    type: MT;
+    payload?: FromChildToParentMessageTypesMap[MT];
+    [key: string]: any;
+}, options?: {
+    overrideStartTime: number;
+}): void;
+/** @deprecated Use editorBridge instead */
+export declare function queueMessage(message: PayloadAction<unknown>): void;
+declare class SbIframeEventInternal<T = Record<string, any>> extends Event {
+    data: {
+        payload: T;
+        startTime: number;
+        [key: string]: any;
+    };
+    constructor(type: FromParentToChildMessageTypes, data: {
+        payload: T;
+        startTime: number;
+        [key: string]: any;
+    });
+}
+interface MessageHandler extends EventTarget {
+    addEventListener<MT extends FromParentToChildMessageTypes>(type: MT, callback: IframeEventHandler<MT>): void;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null): void;
+    removeEventListener<MT extends FromParentToChildMessageTypes>(type: MT, callback: IframeEventHandler<MT>): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null): void;
+}
+declare const SbMessageHandler_base: {
+    new (): MessageHandler;
+    prototype: MessageHandler;
+};
+declare class SbMessageHandler extends SbMessageHandler_base {
+}
+export type IframeEventHandler<MT extends FromParentToChildMessageTypes> = (event: SbIframeEventInternal<FromParentToChildMessageTypesMap[MT]>) => void;
+export declare const iframeMessageHandler: SbMessageHandler;
+export type IframeEvent<T> = T extends FromParentToChildMessageTypes ? MessageEvent<{
+    type: T;
+    payload: FromParentToChildMessageTypesMap[T];
+}> : never;
+export {};

package/dist-types/lib/internal-details/lib/mobx-cached-getter.d.ts

@@ -0,0 +1 @@
+export declare const makeMobxCachedGetter: <T, K extends string>(getter: (id: K) => T) => ((id: K) => T);

package/dist-types/lib/internal-details/lib/resolve-id-singleton.d.ts

@@ -0,0 +1,4 @@
+export declare function addNewPromise(resolver: (...args: any[]) => any, isMultiUse?: boolean, rejecter?: (...args: any[]) => any): string;
+export declare function resolveById(id: string, payload: any): void;
+export declare function rejectById(id: string, payload: any): void;
+export declare function clearMultiCallback(id: string): void;

package/dist-types/lib/internal-details/lib/root-store.d.ts

@@ -0,0 +1,35 @@
+import { LocationStore } from "../location-store.js";
+import ApiManager from "./features/api-store.js";
+import { ComponentRegistry } from "./features/component-registry.js";
+import { NameManager } from "./features/name-manager.js";
+import type { IEntityManager } from "./evaluator/base-entity-manager.js";
+import type { EditStore } from "../../../edit-mode/edit-store.js";
+declare class RootStore {
+    apis: ApiManager;
+    nameManager: NameManager;
+    entityManager: IEntityManager;
+    componentRegistry: ComponentRegistry;
+    editStore?: EditStore;
+    locationStore: LocationStore;
+    applicationId: string | undefined;
+    userId: string | undefined;
+    windowOriginUrl: string | undefined;
+    private editorRegisteredCallbacks;
+    private apisLoaded;
+    private pageScopeLoaded;
+    private pageLoadedCallback?;
+    constructor();
+    setEditStore(editStore: EditStore): void;
+    onEditorRegistered(fn: () => void): void;
+    /**
+     * There is a timing problem here between when the APIs are registered and when the scope entities are registered.
+     * Regardless of which one is done first, we need to wait for both before firing page load actions
+     */
+    setApisLoaded(): void;
+    setPageScopeLoaded(): void;
+    private firePageLoadedCallbacks;
+    onPageLoaded(fn: () => void): void;
+}
+export type { RootStore };
+declare const _default: RootStore;
+export default _default;

package/dist-types/lib/internal-details/lib/suspense/suspense-fallback.d.ts

@@ -0,0 +1,11 @@
+import type { CSSProperties, ReactNode } from "react";
+interface Props {
+    children?: ReactNode;
+    style?: () => CSSProperties;
+    noBorderRadius?: boolean;
+}
+/**
+ * Default fallback component displayed while components are suspended.
+ */
+export declare function SuspenseFallback({ style, noBorderRadius }: Props): import("react").JSX.Element;
+export {};

package/dist-types/lib/internal-details/lib/throttle.d.ts

@@ -0,0 +1,4 @@
+export declare function throttle<T extends (...args: any[]) => any>(func: T, delay: number): ((...args: Parameters<T>) => void) & {
+    cancel: () => void;
+};
+export declare function debounce<T extends (...args: any[]) => any>(func: T, delay: number): (...args: Parameters<T>) => void;

package/dist-types/lib/internal-details/lib/types.d.ts

@@ -0,0 +1,298 @@
+import type { PropertiesPanelDefinition } from "@superblocksteam/library-shared/props";
+import type { UrlState, AppToEditorMessage, DeleteMeLibraryApi, EditOperationPayload, EditOperationType, PayloadAction, PropertyInfo, SbElement, SourceLocation, TransactionInfo, AiContextMode } from "@superblocksteam/library-shared/types";
+import type { OrchestratorViewMode, PlaceholderInfo } from "@superblocksteam/shared";
+import type { XYCoord } from "react-dnd";
+export type ExecutionError = {
+    name?: string;
+    message: string;
+    formPath: string;
+    blockPath: string;
+    handled?: boolean;
+};
+export type ExecutionEventRequest = {
+    summary: string;
+    metadata: {
+        placeHoldersInfo?: Record<string, PlaceholderInfo>;
+    };
+};
+export type Resolutions = Record<string, // name of the field: eg: "range", for the range field let's say the code is {{[1,2,3]}}
+{
+    value: any;
+    bindings: any[];
+}>;
+export type ExecutionEvent = {
+    name: string;
+    type: string;
+    timestamp: string;
+    start?: Record<string, unknown>;
+    end?: {
+        performance?: {
+            start: string | number;
+            finish: string | number;
+            total: string | number;
+            execution: string | number;
+            overhead: string | number;
+        };
+        error?: ExecutionError;
+        output?: {
+            result?: any;
+            request?: string;
+            requestV2?: ExecutionEventRequest;
+            stdout?: Array<string>;
+            stderr?: Array<string>;
+        };
+        resolved?: Resolutions;
+    };
+    parent: string;
+};
+export interface StreamEvent {
+    result: {
+        event: ExecutionEvent;
+        execution: string;
+    };
+}
+export interface ApiV2ExecutionResponse {
+    execution: string;
+    output?: {
+        result: any;
+    };
+    status: "STATUS_EXECUTING" | "STATUS_COMPLETED" | "STATUS_UNSPECIFIED";
+    events?: Array<ExecutionEvent | StreamEvent>;
+    errors?: Array<{
+        message: string;
+        handled?: boolean;
+    }>;
+}
+interface BaseExecutionRequest {
+    options: {
+        includeEventOutputs: boolean;
+        includeEvents: boolean;
+        includeResolved: boolean;
+    };
+    inputs: Record<string, any>;
+}
+interface ApiDefinitionExecutionRequest extends BaseExecutionRequest {
+    definition: {
+        api: Omit<DeleteMeLibraryApi["apiPb"], "trigger">;
+    };
+}
+interface ApiFetchExecutionRequest extends BaseExecutionRequest {
+    fetchByPath: {
+        path: string;
+        applicationId: string;
+        branchName: string;
+        profile: {
+            name: string;
+        };
+        viewMode: OrchestratorViewMode;
+    };
+}
+export type ApiV2ExecutionRequest = ApiDefinitionExecutionRequest | ApiFetchExecutionRequest;
+export type ExecutionResponse = ApiV2ExecutionResponse | {
+    systemError: string;
+};
+export type RouteInfo = Omit<UrlState, "host" | "hostname" | "href" | "port" | "protocol">;
+export type RouteChangePayload = Omit<UrlState, "host" | "hostname" | "href" | "pathname" | "port" | "protocol">;
+export type AiUpdatesPayload = {
+    parentToChild: {
+        type: "start-editing";
+        components?: SbElement[];
+    } | {
+        type: "finish-editing";
+    } | {
+        type: "update-editing-entities";
+        components: SbElement[];
+    } | {
+        type: "set-ai-context-mode";
+        mode: AiContextMode;
+        components?: SbElement[];
+    } | {
+        type: "set-tagging-enabled";
+        isTaggingEnabled: boolean;
+    };
+    childToParent: {
+        type: "add-component-to-context";
+        component: SbElement;
+    } | {
+        type: "toggle-component-in-context";
+        component: SbElement;
+    } | {
+        type: "set-ai-context-mode";
+        mode: AiContextMode;
+    };
+};
+export type FromParentToChildMessageTypesMap = {
+    "sb-init": {
+        peerId: string;
+        userId?: string;
+        appId: string;
+        sessionRecordingKey?: string;
+    };
+    "sb-bootstrap-response": {
+        userId?: string;
+        appId: string;
+        token: string;
+        accessToken: string;
+        /** @deprecated Use agentUrls instead */
+        agentUrl?: string;
+        agentUrls: string[];
+        logContext: Record<string, unknown>;
+        sessionRecordingKey?: string;
+    };
+    "sb-editor-request-bootstrap": void;
+    "sb-update-active-agents": {
+        agentUrls: string[];
+    };
+    "sb-update-property-with-effects": {
+        sourceId: string;
+        callbackId: string;
+        updates: Record<string, PropertyInfo<unknown>>;
+        transaction: TransactionInfo;
+    };
+    "sb-edit-operation-acknowledge": EditOperationPayload<EditOperationType>;
+    "sb-retrieve-property-panel-props": {
+        sourceId: string;
+    };
+    "sb-global-sync": {
+        global: Record<string, unknown>;
+    };
+    "parent-action-batch": PayloadAction<unknown>[];
+    click: void;
+    "register-keypress": {
+        keys: string;
+        options?: any;
+    };
+    "canvas-scale-update": {
+        canvasScaleFactor: number;
+    };
+    "resolve-promise": unknown;
+    "reject-promise": unknown;
+    "flash-element": {
+        elementId: string;
+    };
+    "set-theme": {
+        theme: unknown;
+        updateRedux?: boolean;
+        storedTypographies?: unknown;
+    };
+    getDropTarget: {
+        parentId: string;
+    };
+    keypress: {
+        keys: string;
+        eventInfo: {
+            code: string;
+            key: string;
+            altKey: boolean;
+            ctrlKey: boolean;
+            shiftKey: boolean;
+        };
+    };
+    dragstart: Record<string, unknown> & {
+        type: string;
+    };
+    "sb-create-component": {
+        componentType: string;
+        parent: SourceLocation;
+        scopeName: string;
+        baseProperties?: Record<string, PropertyInfo>;
+        skipSecondaryComponentsCreation?: boolean;
+        otherComponentsUpdates?: Record<SbElement, Record<string, PropertyInfo>>;
+    };
+    /**
+     * Request a route change in the child
+     */
+    "route-change": RouteChangePayload;
+    "ai-updates": AiUpdatesPayload["parentToChild"];
+};
+export type FromParentToChildMessageTypes = keyof FromParentToChildMessageTypesMap;
+export type FromChildToParentMessageTypesMap = {
+    "sb-ready": void;
+    "iframe-action-batch": PayloadAction<unknown>[];
+    /**
+     * Navigate the parent window to a new URL
+     */
+    "navigate-to": {
+        url: string;
+        newWindow?: boolean;
+    };
+    "sb-iframe-track-changes": Record<string, unknown>;
+    "resolve-promise": unknown;
+    "reject-promise": unknown;
+    "sb-editor-request-bootstrap": void;
+    "reload-configs": void;
+    "sb-edit-operation-request": EditOperationPayload<EditOperationType>;
+    "client:selectWidgets": {
+        sourceIds: SbElement[];
+    };
+    getDropTargetResult: {
+        offset: XYCoord;
+        size: {
+            height: number;
+            width: number;
+        };
+    };
+    keypress: {
+        keys: string;
+        eventInfo: {
+            code: string;
+            key: string;
+            altKey: boolean;
+            ctrlKey: boolean;
+            shiftKey: boolean;
+        };
+    };
+    "register-click": {
+        type: string;
+        context: {
+            clientX: number;
+            clientY: number;
+            sourceId: string;
+            insertionIndexes?: {
+                sectionInsertionPosition?: number;
+                columnInsertionPosition?: number;
+                stackInsertionPosition?: number;
+            };
+        };
+    };
+    "api/started-execution": {
+        apiName: string;
+    };
+    "api/set-api-response": {
+        apiName: string;
+        response: unknown;
+    };
+    "api/stream-event": {
+        event: StreamEvent;
+        apiName: string;
+    };
+    "api/stream-message": {
+        message: any;
+        apiName: string;
+    };
+    "authenticate-api-request": {
+        apiId: string;
+        callbackId: string;
+    };
+    "set-apis-deployed-mode": {
+        apis: Array<DeleteMeLibraryApi & {
+            scopeId: string;
+        }>;
+        callbackId: string;
+    };
+    /**
+     * Notify the parent of a route change
+     */
+    "route-change": RouteChangePayload;
+    "ai-updates": AiUpdatesPayload["childToParent"];
+    undo: void;
+    redo: void;
+    "socket/error": {
+        message: string;
+    };
+    "logout-integration": {
+        callbackId: string;
+    };
+} & AppToEditorMessage<PropertiesPanelDefinition>;
+export type FromChildToParentMessageTypes = keyof FromChildToParentMessageTypesMap;
+export {};

package/dist-types/lib/internal-details/location-store.d.ts

@@ -0,0 +1,13 @@
+import { type DataRouter, type Location } from "react-router";
+import type { RootStore } from "./lib/root-store.js";
+import type { RouteInfo } from "./lib/types.js";
+import type { Params } from "react-router";
+export declare class LocationStore {
+    route?: RouteInfo;
+    rootStore: RootStore;
+    constructor(rootStore: RootStore);
+    updateLocation(location: Location, routes: DataRouter["routes"], params: Readonly<Params<string>>): void;
+    sendLocationToEditor(): void;
+    updateGlobalScopeUrl(): Promise<void>;
+    locationToRouteInfo(location: Location, routes: DataRouter["routes"], params: Readonly<Params<string>>): RouteInfo | undefined;
+}

package/dist-types/lib/internal-details/reactive-component.d.ts

@@ -0,0 +1,11 @@
+import type { IdentifierInfo } from "./lib/features/name-manager.js";
+import type { ChildFunction } from "../../edit-mode/features/runtime-widgets-manager.js";
+type ReactiveComponentProps = {
+    children: React.ReactNode | ChildFunction;
+    Component: React.FC<any>;
+    widgetProps: Record<string, unknown>;
+    showErrors?: boolean;
+    identifier: IdentifierInfo;
+};
+declare const WrappedReactiveComponent: (props: ReactiveComponentProps) => import("react").JSX.Element;
+export default WrappedReactiveComponent;

package/dist-types/lib/internal-details/remove-bindings.d.ts

@@ -0,0 +1 @@
+export declare function removeBindings(props: Record<string, unknown>): Record<string, unknown>;

package/dist-types/lib/internal-details/routing.d.ts

@@ -0,0 +1,2 @@
+export declare function useTrackRouteChange(): void;
+export declare function useInterceptNavigation(): void;

package/dist-types/lib/internal-details/sb-wrapper.d.ts

@@ -0,0 +1,98 @@
+import React from "react";
+import type { ExternalProps, InternalProps, PropertiesDefinition, RawPropsToExternal } from "../user-facing/properties-panel/props-builder.js";
+import type { AnonymousSbEntity, CreateChild, PropertyInfo, Catalog, EditorConfig } from "@superblocksteam/library-shared/types";
+export type DropTargetProps = {
+    dropTargetRef?: React.RefObject<HTMLDivElement>;
+};
+export type ParentInfo = {
+    isGridLike: boolean;
+    type?: string;
+};
+export interface CreationContext {
+    generateUniqueName: (baseName: string) => string;
+    parentInfo: ParentInfo;
+}
+export type PropertyValues<Def extends PropertiesDefinition> = {
+    [K in keyof GetAllPropsFromDefinition<Def>]?: PropertyInfo | PropertyValues<Def>;
+};
+type GetAllPropsFromDefinition<Def extends PropertiesDefinition> = {
+    [SectionKey in keyof Def]: Def[SectionKey] extends {
+        props: infer Props;
+    } ? Props extends Record<string, any> ? Props : never : never;
+}[keyof Def];
+export interface EditorTemplate<Def extends PropertiesDefinition> {
+    catalog?: Catalog;
+    /***
+     * Config for the newly created component when added to the canvas from the Editor.
+     * @returns a single CreateRequest or an array of CreateRequests.
+     *
+     * When returning Array<CreateRequests>:
+     *  - The 1st CreateRequest's type must match the componentType passed to createComponent.
+     *  - The last CreateRequest's will be the selected component after drag & drop.
+     *
+     *  Example: [Modal, Button]
+     *  A modal that when drag & dropped on the page will add a trigger button.
+     *  The modal is closed by default, so the selected component after drop will be the trigger button.
+     */
+    create?: (context: CreationContext) => CreateRequest<Def> | Array<CreateRequest<Def>>;
+}
+export interface CreateRequest<Def extends PropertiesDefinition> {
+    type: string;
+    /**
+     * Should it automatically generate a binding?
+     * e.g: <Input bind={Input1}>
+     *
+     * Default is false (no binding)
+     *
+     * `generateBinding` can also receive a string. e.g: "Input1".
+     *  This is useful if you need to create children components that rely on the parent's binding (e.g: a button inside a modal to close the modal).
+     *  To generate these unique names, you can use `context.generateUniqueName` and pass the component type (e.g: "Modal")
+     *
+     * A good rule of thumb:
+     * - Components that expose a user's input should have an automatically generated binding (e.g: Input, Checkbox, Table, etc)
+     * - Components that don't expose a user's input should not have an automatically generated binding (e.g: Button, Text, etc)
+     *
+     * Note:
+     * Apps builders can always manually set a binding on the editor or source code.
+     */
+    generateBinding?: boolean | string;
+    properties?: PropertyValues<Def>;
+    createAt?: "root" | "dropLocation";
+    children?: CreateChild[];
+}
+export interface ChainableComponent<PD extends PropertiesDefinition, EP extends ExternalProps<PD>> extends React.FC<EP> {
+    addEditorTemplate: (config: EditorTemplate<PD>) => ChainableComponent<PD, EP>;
+    editorConfig: (config: EditorConfig) => ChainableComponent<PD, EP>;
+    isSb: symbol;
+    sbType: string;
+    displayName: string;
+    isCustomComponent: boolean;
+    isDroppable: boolean;
+    hasExtendedClickArea: boolean;
+    propertiesDefinition: PropertiesDefinition;
+}
+/**
+ * Register a component to be used with the framework.
+ *
+ * Returns a chainable component that can be used as a React component and also provides
+ * additional methods for editor integration.
+ *
+ * // TODO: All these params should be migrated to editor template or editorConfig
+ * @param type - The string identifier for the component type. This should be unique, is used internally to reference the component, and is also the tag name on source code.
+ * @param config - An object containing configuration options for the component:
+ *   - customComponent (optional): If true, marks this as a custom user-defined component.
+ *   - hasExtendedClickArea (optional): If true, the component will have an extended clickable area in the editor.
+ *   - propertiesDefinition: The definition of the component's properties, used for property panel generation and validation.
+ * @param Component - The React functional component implementation. Receives internal props (including drop target props) as its argument.
+ *
+ * @returns A chainable component that can be used as a React component and also provides methods for editor integration (such as addEditorTemplate and editorConfig).
+ */
+export declare const registerComponentInternal: <PD extends PropertiesDefinition, EP extends ExternalProps<PD> = ExternalProps<PD>, IP extends InternalProps<PD> & DropTargetProps = InternalProps<PD> & DropTargetProps>(type: string, config: {
+    customComponent?: boolean;
+    hasExtendedClickArea?: boolean;
+    propertiesDefinition: PD;
+}, Component: React.FC<IP>) => ChainableComponent<PD, EP>;
+export declare function registerEntity<PROPS, PD extends PropertiesDefinition, EP extends ExternalProps<PD> = ExternalProps<PD>>(name: string, config: {
+    propertiesDefinition: PD;
+}, Entity: (args: RawPropsToExternal<PROPS>) => EP & AnonymousSbEntity): (args: RawPropsToExternal<PROPS>) => EP & AnonymousSbEntity;
+export {};

package/dist-types/lib/internal-details/sb-wrapper.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-types/lib/internal-details/scope/global.d.ts

@@ -0,0 +1,11 @@
+import type { Global as GlobalType } from "./types.js";
+import type { Theme as BaseTheme, UserAccessibleTheme } from "@superblocksteam/library-shared/types";
+export declare const GlobalScope: import("react").FC<import("react").JSX.IntrinsicAttributes & {
+    children: React.ReactNode;
+}>;
+export declare const updateGlobalScope: (global: Record<string, unknown>) => void;
+export type AppTheme = BaseTheme;
+export declare const Theme: UserAccessibleTheme;
+export declare const Global: GlobalType;
+export declare const Embed: any;
+export declare const Env: any;

package/dist-types/lib/internal-details/scope/scope-context.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { ScopeId } from "../lib/evaluator/base-entity-manager.js";
+type State = {
+    scopeId: ScopeId;
+};
+export declare const ScopeProvider: React.FC<React.PropsWithChildren<State>>;
+export declare const useScope: () => State;
+export {};

package/dist-types/lib/internal-details/scope/scope.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import type { SbApi } from "../../user-facing/entities/api/index.js";
+import type { Timer } from "../../user-facing/entities/timer/index.js";
+import type { StateVar } from "../../user-facing/entities/variable/index.js";
+import type { ScopeInstance } from "../../user-facing/state/types.js";
+import type { SbEvent } from "../entities.js";
+import type { ScopeOptions } from "@superblocksteam/library-shared/types";
+export type ScopedEntity = ReturnType<typeof Timer> | ReturnType<typeof StateVar> | ReturnType<typeof SbEvent> | ReturnType<typeof SbApi>;
+export type Scope = {
+    [key: string]: ScopedEntity;
+};
+export declare function registerScope<T>(Component: React.FC<T>, scopeDef: ScopeInstance<any>, options?: ScopeOptions): React.FC<React.JSX.IntrinsicAttributes & T>;

package/dist-types/lib/internal-details/scope/types.d.ts

@@ -0,0 +1,48 @@
+import type { UrlState } from "@superblocksteam/library-shared/types";
+import type { Profile, RouteDef } from "@superblocksteam/shared";
+export declare const AppMode: {
+    readonly EDIT: "EDIT";
+    readonly PUBLISHED: "PUBLISHED";
+    readonly PREVIEW: "PREVIEW";
+};
+export type AppMode = (typeof AppMode)[keyof typeof AppMode];
+export interface Global {
+    mode?: AppMode;
+    user?: User;
+    URL?: UrlState;
+    groups?: Group[];
+    deployedAt?: string;
+    createdAt?: string;
+    selectedProfileId?: string;
+    profiles?: Profiles;
+    routes?: {
+        [id: string]: RouteDef;
+    };
+    currentRoute?: {
+        routeDef: RouteDef;
+        params: Record<string, string>;
+    };
+    app?: {
+        id: string;
+        name: string;
+    };
+}
+type User = {
+    name: string;
+    email: string;
+    id: string;
+    groups: Group[];
+    username: string;
+    metadata: Record<string, unknown>;
+};
+type Group = {
+    id: string;
+    name: string;
+    size: number;
+};
+type Profiles = {
+    available: Profile[];
+    selected?: Profile;
+    default: Profile;
+};
+export {};

package/dist-types/lib/internal-details/size.d.ts

@@ -0,0 +1 @@
+export declare const getWidthInColumns: (itemWidth: number, gridWidth: number, columns: number) => number;

package/dist-types/lib/internal-details/theme-context.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { UserAccessibleTheme } from "@superblocksteam/library-shared/types";
+export declare const ThemeProvider: React.FC<React.PropsWithChildren<{
+    theme: UserAccessibleTheme;
+}>>;
+export declare const useTheme: () => {
+    theme: UserAccessibleTheme;
+};

package/dist-types/lib/internal-details/use-track-runtime-widget.d.ts

@@ -0,0 +1,15 @@
+import type { Name } from "./lib/evaluator/names.js";
+import type { ChildFunction } from "../../edit-mode/features/runtime-widgets-manager.js";
+import type { SbElement, SbInstance } from "@superblocksteam/library-shared/types";
+import type { ReactNode } from "react";
+declare function useTrackRuntimeWidget(instanceId: SbInstance, params: {
+    name: Name;
+    type: string;
+    props: Record<string, unknown> & {
+        children?: ReactNode[] | ReactNode | ChildFunction;
+    };
+    isEditing: boolean;
+    scopeId: string;
+    sourceId: SbElement;
+}): void;
+export default useTrackRuntimeWidget;

package/dist-types/lib/internal-details/utils/is-local-link.d.ts

@@ -0,0 +1 @@
+export declare function isLocalLink(href: string): boolean;