@superblocksteam/library 2.0.3-next.71

package/dist-types/edit-mode/superblocks-editor-bridge.d.ts

@@ -0,0 +1,34 @@
+import type { FromChildToParentMessageTypesMap } from "../lib/index.js";
+import type { StreamEvent } from "../lib/internal-details/lib/types.js";
+import type { PropertiesPanelDefinition } from "@superblocksteam/library-shared/props";
+import type { GeneratedTheme, SbElement, Theme } from "@superblocksteam/library-shared/types";
+export declare class SuperblocksEditorBridge {
+    private static instance;
+    private messagesToSend;
+    private connectedToParent;
+    static getInstance(): SuperblocksEditorBridge;
+    connected(): void;
+    sendReady(): void;
+    sendNotification(type: "success" | "error" | "info" | "warning", message: string, description?: string): void;
+    selectWidgets(sourceIds: SbElement[], selectingMultiple?: boolean): void;
+    updateWidgetProperty(sourceId: string, updates: Record<string, unknown>): void;
+    deleteWidgets(sourceIds: SbElement[]): void;
+    undo(): void;
+    redo(): void;
+    sendStreamedApiEvent(event: StreamEvent, apiName: string): void;
+    sendStreamedApiMessage(message: any, apiName: string): void;
+    setApiStarted(apiName: string): void;
+    setApiResponse(apiName: string, response: unknown): void;
+    navigateTo(path: string, newWindow?: boolean): void;
+    updateTheme(theme: Theme, generatedTheme: GeneratedTheme): void;
+    updatePropertiesPanels(updates: Record<string, PropertiesPanelDefinition>): void;
+    addPropertiesPanel(id: string, definition: PropertiesPanelDefinition): void;
+    initializeEditorSyncedStore(payload: FromChildToParentMessageTypesMap["codeMode/editor-synced-store/init"]): void;
+    updateEditorSyncedStore(payload: FromChildToParentMessageTypesMap["codeMode/editor-synced-store/update"]): void;
+    resolvePromise(callbackId: string, payload: unknown): void;
+    rejectPromise(callbackId: string, payload: unknown): void;
+    canvasClicked(): void;
+    private queueMessage;
+    private sendImmediate;
+}
+export declare const editorBridge: SuperblocksEditorBridge;

package/dist-types/internal-testing/components/api.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const _default: React.MemoExoticComponent<() => React.JSX.Element>;
+export default _default;

package/dist-types/internal-testing/components/button.d.ts

@@ -0,0 +1 @@
+export default function Widgets(): import("react").JSX.Element;

package/dist-types/internal-testing/components/checkbox.d.ts

@@ -0,0 +1 @@
+export default function Widgets(): import("react").JSX.Element;

package/dist-types/internal-testing/components/container.d.ts

@@ -0,0 +1 @@
+export default function Widgets(): import("react").JSX.Element;

package/dist-types/internal-testing/components/date-picker.d.ts

@@ -0,0 +1 @@
+export default function Widgets(): import("react").JSX.Element;

package/dist-types/internal-testing/components/dropdown.d.ts

@@ -0,0 +1 @@
+export default function Widgets(): import("react").JSX.Element;

package/dist-types/internal-testing/components/icon.d.ts

@@ -0,0 +1 @@
+export default function Widgets(): import("react").JSX.Element;

package/dist-types/internal-testing/components/image.d.ts

@@ -0,0 +1 @@
+export default function Image(): import("react").JSX.Element;

package/dist-types/internal-testing/components/input.d.ts

@@ -0,0 +1 @@
+export default function Widgets(): import("react").JSX.Element;

package/dist-types/internal-testing/components/key-value.d.ts

@@ -0,0 +1 @@
+export default function KeyValue(): import("react").JSX.Element;

package/dist-types/internal-testing/components/modal.d.ts

@@ -0,0 +1 @@
+export default function Widgets(): import("react").JSX.Element;

package/dist-types/internal-testing/components/section-column.d.ts

@@ -0,0 +1 @@
+export default function Widgets(): import("react").JSX.Element;

package/dist-types/internal-testing/components/switch.d.ts

@@ -0,0 +1 @@
+export default function Widgets(): import("react").JSX.Element;

package/dist-types/internal-testing/components/table.d.ts

@@ -0,0 +1 @@
+export default function Widgets(): import("react").JSX.Element;

package/dist-types/internal-testing/components/timer.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const _default: React.MemoExoticComponent<() => React.JSX.Element>;
+export default _default;

package/dist-types/internal-testing/components/variable.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const _default: React.MemoExoticComponent<() => React.JSX.Element>;
+export default _default;

package/dist-types/internal-testing/utils.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export declare function WidgetWrapper({ label, children, }: {
+    label: string;
+    children: React.ReactNode;
+}): React.JSX.Element;

package/dist-types/internal-testing/widgets.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare function Widgets(): React.JSX.Element;

package/dist-types/lib/hooks/use-alignment-styles.d.ts

@@ -0,0 +1,9 @@
+import { type VerticalAlignment, type HorizontalAlignment } from "../user-facing/component-base/constants.js";
+import type { ContainerLayout } from "../user-facing/component-base/constants.js";
+import type { CSSProperties } from "react";
+declare const useAlignmentStyles: ({ layout, verticalAlign, horizontalAlign, }: {
+    layout?: ContainerLayout;
+    verticalAlign?: VerticalAlignment;
+    horizontalAlign?: HorizontalAlignment;
+}) => CSSProperties;
+export default useAlignmentStyles;

package/dist-types/lib/hooks/use-cached-value.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A hook that caches a (non-primitive) value and returns the cached value for as long it
+ * does not change with respect to a deep equality function.
+ * This is useful when a non-primitive is to be used in a dependency array:
+ * the cached value returned will be referentially the same object for as long as the
+ * object has not changed and therefore the dependency will not change.
+ * @param value     The value to cache. It does not make sense use this hook for primitive values.
+ * @param isEqualFn The (deep) equality function to compare objects, defaults to `isEqual` from lodash.
+ * @returns         `value` or a cached version of `value` that is (deeply) equal to `value`.
+ */
+export declare function useCachedValue<T>(value: T, isEqualFn?: (cachedValue: T, curValue: T) => boolean): T;

package/dist-types/lib/hooks/use-callback-as-ref.d.ts

@@ -0,0 +1 @@
+export declare const useCallbackAsRef: <T extends (...args: any[]) => any>(callback: T) => (...args: any) => any;

package/dist-types/lib/hooks/use-deep-memo.d.ts

@@ -0,0 +1,9 @@
+import type { DependencyList } from "react";
+/**
+ * Custom hook that memoizes a value based on deep equality of dependencies.
+ * @param factory A function that returns the value to be memoized.
+ * @param deps An array of dependencies that trigger the memoization.
+ * @returns The memoized value.
+ */
+declare const useDeepMemo: <T>(factory: () => T, deps: DependencyList) => T;
+export default useDeepMemo;

package/dist-types/lib/hooks/use-editor-hotkeys.d.ts

@@ -0,0 +1,3 @@
+import type { KeyHandler } from "hotkeys-js";
+import type { Options } from "react-hotkeys-hook";
+export declare function useEditorHotkeys<T extends Element>(keys: string, callback: KeyHandler, options?: any[] | Options, deps?: any[]): React.MutableRefObject<T | null> | undefined;

package/dist-types/lib/hooks/use-element-rect.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import type { Options as DebounceSettings } from "use-debounce";
+export declare function useElementRect<T extends HTMLElement>(target: React.RefObject<T> | T | null, wait?: number, options?: DebounceSettings): DOMRect | undefined;
+export declare function useElementWidth<T extends HTMLElement>(target: React.RefObject<T> | T | null, wait?: number): number;
+export declare function useHeightChange<T extends HTMLElement>(target: React.RefObject<T> | T | null, onChange: (height: number) => void, wait?: number): void;
+export declare function useWidthChange<T extends HTMLElement>(target: React.RefObject<T> | T | null, onChange: (width: number) => void, wait?: number): void;
+export declare function useRectChange<T extends HTMLElement>(target: React.RefObject<T> | T | null, onChange: (width: number, height: number) => void, wait?: number): void;

package/dist-types/lib/hooks/use-observer-memo.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The component that uses this hook must be wrapped `observer`, otherwise state changes will not
+ * cause this hook to re-run.
+ */
+export declare const useObserverMemo: <T>(fn: () => T, deps: any[]) => T;
+/**
+ * Like useObserverMemo, but does not require the component to be wrapped in an observer.
+ * It is recommended to use useObserverMemo instead.
+ * @see useObserverMemo
+ *
+ * Note: This implementation uses MobX reactions to track both observable changes and
+ * dependency changes.
+ */
+export declare const useStandaloneObserverMemo: <T>(fn: () => T, deps: any[]) => T;

package/dist-types/lib/hooks/use-observer-memo.test.d.ts

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

package/dist-types/lib/hooks/use-pointer-down-outside.d.ts

@@ -0,0 +1,15 @@
+import type React from "react";
+/**
+ * Calls @param onClickOutside when the user clicks outside of a set of elements
+ *
+ * @param  - `wrapperRefs, wrapperIds, wrapperSelectors` - Arrays of refs to DOM elements that should be considered "wrappers" for
+ * the click outside handler. If the user clicks outside of all of these elements, the callback will be
+ * called.
+ * @param - onClickOutside - A callback function that will be called when the user clicks outside of the wrappers
+ */
+export declare function usePointerDownOutside({ wrapperRefs, wrapperIds, wrapperSelectors, onClickOutside, }: {
+    wrapperRefs?: Array<React.MutableRefObject<Element | null | undefined>>;
+    wrapperIds?: Array<string>;
+    wrapperSelectors?: Array<string>;
+    onClickOutside: () => void;
+}): void;

package/dist-types/lib/hooks/use-stable-effect.d.ts

@@ -0,0 +1,22 @@
+import type React from "react";
+type isType = (a: unknown) => boolean;
+type isEqual = (a: any, b: any) => boolean;
+/**
+ * Options for the useStableEffect hook.
+ */
+export interface UseStableEffectOptions {
+    customEqualChecks?: [isType, isEqual][];
+    ignoreKeys?: string[];
+    cold?: boolean;
+}
+/**
+ * Custom hook that runs an effect only when specified properties of an object change.
+ *
+ * @param effect - The effect callback to run.
+ * @param obj - The object whose properties are checked for changes.
+ * @param options - Optional custom equality checks and keys to ignore when checking for changes.
+ */
+declare const useStableEffect: (effect: React.EffectCallback, obj: {
+    [key: string]: unknown;
+}, options?: UseStableEffectOptions) => void;
+export default useStableEffect;

package/dist-types/lib/hooks/use-stable-effect.test.d.ts

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

package/dist-types/lib/index.d.ts

@@ -0,0 +1,40 @@
+import "./style.css";
+import "../edit-mode/edit-style.css";
+export { SbButton } from "./user-facing/components/button/index.jsx";
+export { SbSection } from "./user-facing/components/section/index.jsx";
+export { SbColumn } from "./user-facing/components/column/index.jsx";
+export { SbContainer } from "./user-facing/components/container/index.jsx";
+export { SbInput } from "./user-facing/components/input/index.jsx";
+export { SbPage } from "./user-facing/components/page/index.jsx";
+export { SbText } from "./user-facing/components/text/index.jsx";
+export { SbModal } from "./user-facing/components/modal/index.jsx";
+export { SbSlideout } from "./user-facing/components/slideout/index.jsx";
+export { SbTable } from "./user-facing/components/table/index.jsx";
+export { SbDropdown } from "./user-facing/components/dropdown/index.jsx";
+export { SbCustom } from "./user-facing/components/custom/index.jsx";
+export { SbKeyValue } from "./user-facing/components/key-value/index.jsx";
+export { registerComponent, type CustomComponentProps, } from "./user-facing/components/custom/register-custom-component.jsx";
+export { SbCheckbox } from "./user-facing/components/checkbox/index.jsx";
+export { SbDatePicker } from "./user-facing/components/date-picker/index.jsx";
+export { SbSwitch } from "./user-facing/components/switch/index.jsx";
+export { SbIcon } from "./user-facing/components/icon/index.jsx";
+export { SbImage } from "./user-facing/components/image/index.jsx";
+export { SbVariable, SbVariablePersistence, } from "./user-facing/entities/variable/index.js";
+export { SbTimer } from "./user-facing/entities/timer/index.js";
+export { SbApi } from "./user-facing/entities/api/index.js";
+export { default as MakeEditableWithSuperblocks } from "./user-facing/sb-provider.jsx";
+export { default as SbProvider } from "./user-facing/sb-provider.jsx";
+export { SbEventFlow } from "./user-facing/sb-event-flow.js";
+export { copyToClipboard, navigateTo, setQueryParams, download, showAlert, logoutIntegrations, } from "./user-facing/global-functions.js";
+export { registerScope } from "./internal-details/scope/scope.jsx";
+export { registerPage } from "./user-facing/components/page/register-page.js";
+export { createSbScope } from "./user-facing/state/create-scope.js";
+export { type BindingIdentifier } from "./user-facing/state/types.js";
+export { SbEvent } from "./internal-details/entities.js";
+export { useUpdateProperties } from "./user-facing/hooks/use-update-properties.js";
+export { Prop } from "./user-facing/properties-panel/props-builder.js";
+export { sbComputed } from "./user-facing/state/sb-computed.js";
+export { Dim, type DimModes, SB } from "@superblocksteam/library-shared";
+export type { Theme } from "@superblocksteam/library-shared/types";
+export type { FromChildToParentMessageTypes, FromChildToParentMessageTypesMap, FromParentToChildMessageTypes, FromParentToChildMessageTypesMap, } from "./internal-details/lib/types.js";
+export { Outlet } from "react-router";

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

@@ -0,0 +1,9 @@
+import React from "react";
+import type { createEntityActions } from "./entities-state.js";
+export declare const ActionsProvider: React.FC<React.PropsWithChildren<{
+    actions: ReturnType<typeof createEntityActions>;
+}>>;
+export declare const useActions: () => {
+    reset: () => void;
+    update: (run: (entity: import("./lib/evaluator/base-entity-manager.js").Entity) => void) => void;
+};

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

@@ -0,0 +1,10 @@
+import React from "react";
+import type { SbElement, SbInstance } from "@superblocksteam/library-shared/types";
+type ComponentInfo = {
+    sourceId: SbElement;
+    instanceId: SbInstance;
+    name: string;
+};
+export declare const ComponentInfoProvider: React.FC<React.PropsWithChildren<ComponentInfo>>;
+export declare const useComponentInfo: () => ComponentInfo;
+export {};

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

@@ -0,0 +1,10 @@
+import type { Entity, ScopeId } from "./lib/evaluator/base-entity-manager.js";
+declare const entityActions: {
+    reset: (entityName: string, scopeId: ScopeId) => void;
+    update: (entityName: string, scopeId: ScopeId, run: (entity: Entity) => void) => void;
+};
+declare const createEntityActions: (entityName: string, scopeId: ScopeId) => {
+    reset: () => void;
+    update: (run: (entity: Entity) => void) => void;
+};
+export { entityActions, createEntityActions };

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

@@ -0,0 +1,5 @@
+import type { SbEntity, SbEvent as TSbEvent } from "@superblocksteam/library-shared/types";
+export declare function isSbEntity(entity: any): entity is SbEntity;
+export declare function SbEvent({ payload, }: {
+    payload: string;
+}): Omit<TSbEvent, "name" | "id">;

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

@@ -0,0 +1 @@
+export declare const SUPERBLOCKS_UI_MATERIAL_ICON_CDN_PATH: any;

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

@@ -0,0 +1,9 @@
+import type { BindingIdentifier } from "../user-facing/state/types";
+export declare const getNormalizedIdInfo: (params: {
+    bind: BindingIdentifier | undefined;
+    propsName: string | undefined;
+    fallbackScopeId: string;
+}) => {
+    name: string | undefined;
+    scopeId: string;
+};

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

@@ -0,0 +1,7 @@
+import type { SbComponentProps } from "../user-facing/component-base/sb-component";
+import type { ReactNode } from "react";
+type ChildFunction = Function;
+export type StackChildElement = React.ReactElement<SbComponentProps>;
+export declare const superblocksComponentSymbol: unique symbol;
+export declare function isSbComponent(child: ReactNode | ChildFunction): child is StackChildElement;
+export {};

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

@@ -0,0 +1 @@
+export declare function registerStores(stores: Record<string, any>): void;

package/dist-types/lib/internal-details/lib/evaluator/base-entity-manager.d.ts

@@ -0,0 +1,104 @@
+import type { ObserveListener } from "./deep-observe.js";
+import type { Name } from "./names.js";
+import type { ValidateFn } from "../../../user-facing/properties-panel/validators.js";
+import type { SbEventFlow } from "../../../user-facing/sb-event-flow.js";
+import type { BindingString, ComputedProperty, Dim, DimModes } from "@superblocksteam/library-shared";
+import type { SbElement, SbInstance, UserAccessibleTheme } from "@superblocksteam/library-shared/types";
+export type EntityOutputProp = Exclude<null | undefined | string | number | boolean | object | bigint | any[], BindingString | EntityDerivedProp<any[]>>;
+export type EntityDerivedProp<ARGS extends any[] = any[]> = (this: Readonly<Entity>, state: Readonly<ScopedState>, ...args: ARGS) => EntityOutputProp;
+export type Executable<ARGS extends any[] = any[]> = (this: Entity, state: ScopedState, ...args: ARGS) => void;
+export type ValueInputProp<T = EntityOutputProp> = T | EntityDerivedProp | BindingString | ComputedProperty<T>;
+export type SingleInputProp<T = EntityOutputProp> = ValueInputProp<T> | SbEventFlow | Dim<DimModes>;
+export type NestedInputProp<T> = T extends object ? {
+    [K in keyof T]: SingleInputProp<T[K]> | NestedInputProp<T[K]>;
+} : never;
+export type InputProp<T = EntityOutputProp> = SingleInputProp<T> | NestedInputProp<T>;
+export type EntityFunction<ARGS extends any[] = any[], R = EntityOutputProp> = (this: Entity, state: ScopedState, ...args: ARGS) => R;
+export type Entity = {
+    [key: string]: EntityOutputProp;
+    type: string;
+};
+export type ScopeId = string;
+export type GeneralScopedState = {
+    [key: string]: Entity | GeneralScopedState;
+};
+type ThemeEntity = UserAccessibleTheme & {
+    type: "theme";
+};
+export type ScopedState = {
+    theme: ThemeEntity;
+} & GeneralScopedState;
+export type InternalScope = {
+    id: string;
+    name?: string;
+    entities: Record<string, Entity>;
+    entityMeta: Record<string, Entity>;
+    childScopes: Record<ScopeId, InternalScope>;
+    idToName: Record<string, Name>;
+    getEntity(name: Name): Entity;
+    getEntityMeta(name: Name): Entity;
+    getEntityName(id: string): Name;
+    setEntityName(id: string, name: Name, currentName?: Name): void;
+};
+export interface IEntityManager {
+    getFullState: Record<string, Entity>;
+    getScopeName(scopeId: string): string;
+    getState(scopeId: string): ScopedState;
+    getEntity(scopeId: string, name: Name): Entity;
+    getEntityById(scopeId: string, id: SbInstance): Entity;
+    createScope(params: {
+        name?: string;
+        parentScopeId?: ScopeId;
+        scopeId?: string;
+    }): ScopeId;
+    deleteScope(params: {
+        scopeId: ScopeId;
+    }): void;
+    createEntity(params: {
+        scopeId: ScopeId;
+        name: Name;
+        props: Record<string, InputProp>;
+        type: string;
+        instanceId?: SbInstance;
+        sourceId?: SbElement;
+    }): Name;
+    deleteEntity(params: {
+        name: Name;
+        scopeId: ScopeId;
+    }): void;
+    deleteEntityById(params: {
+        scopeId: ScopeId;
+        entityId: string;
+    }): void;
+    resetEntity(params: {
+        scopeId: ScopeId;
+        name: Name;
+        key?: string;
+    }): void;
+    updateEntity(params: {
+        scopeId: ScopeId;
+        name: Name;
+        instanceId?: SbInstance;
+        props: Record<string, InputProp>;
+    }): void;
+    renameEntity(params: {
+        scopeId: ScopeId;
+        instanceId: SbInstance;
+        newName: Name;
+        isDuplicate: boolean;
+    }): void;
+    runCode<ARGS extends any[] = any[]>(params: {
+        scopeId: ScopeId;
+        name: Name;
+        func: Executable<ARGS>;
+        args?: ARGS;
+    }): void;
+    computeValue<T>(params: {
+        scopeId: ScopeId;
+        name: Name;
+        value: SingleInputProp<T>;
+        validator?: ValidateFn<T>;
+    }): T;
+    observeScope(scopeId: string, listener: ObserveListener<InternalScope>): () => void;
+}
+export {};

package/dist-types/lib/internal-details/lib/evaluator/binding-extraction.d.ts

@@ -0,0 +1,2 @@
+import type { IEntityManager } from "./base-entity-manager.js";
+export declare function getApiDeps(entitiesState: IEntityManager, scopeId: string, apiDepCandidates: string[]): any;

package/dist-types/lib/internal-details/lib/evaluator/binding-strings/transform-bindings.d.ts

@@ -0,0 +1,6 @@
+import type { EntityDerivedProp } from "../base-entity-manager.js";
+import type { BindingString } from "@superblocksteam/library-shared";
+declare const transformBindings: (value: BindingString) => Function;
+export declare const toEvalFunc: ([prop, binding]: [string, BindingString]) => [string, EntityDerivedProp];
+export declare const stringToJS: (string: string) => string;
+export default transformBindings;

package/dist-types/lib/internal-details/lib/evaluator/compute-engines.d.ts

@@ -0,0 +1,20 @@
+import type { EntityDerivedProp, EntityOutputProp, ScopedState } from "./base-entity-manager.js";
+import type { Name } from "./names.js";
+export type ComputeParams<ARGS extends any[] = any[]> = {
+    snapshot: Readonly<ScopedState>;
+    entityName: Name;
+    path?: string;
+    func: EntityDerivedProp<ARGS>;
+    args?: ARGS;
+};
+export interface ComputeEngine {
+    compute(params: ComputeParams): EntityOutputProp;
+}
+declare class EvalComputeEngine implements ComputeEngine {
+    private statementFunction;
+    compute({ snapshot, entityName, func, args, path }: ComputeParams): any;
+}
+declare class DirectComputeEngine implements ComputeEngine {
+    compute({ snapshot, entityName, func, args, path }: ComputeParams): EntityOutputProp;
+}
+export { EvalComputeEngine, DirectComputeEngine };

package/dist-types/lib/internal-details/lib/evaluator/create-global-object.d.ts

@@ -0,0 +1,7 @@
+import type { ScopedState } from "./base-entity-manager.js";
+export declare const ARGS_VAR_NAME = "$SB_args";
+export declare const USER_JS_CODE_VAR_NAME = "$SB_userJSCode";
+export declare const SNAPSHOT_VAR_NAME = "$SB_snapshot";
+export declare function createGlobalObject({ snapshot, }: {
+    snapshot: Readonly<ScopedState>;
+}): Record<string, unknown>;

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

@@ -0,0 +1,2 @@
+import type { ScopedState, InternalScope } from "./base-entity-manager.js";
+export declare function createScopeProxy(scopes: InternalScope[]): ScopedState;

package/dist-types/lib/internal-details/lib/evaluator/deep-observe.d.ts

@@ -0,0 +1,27 @@
+import type { Entity } from "./base-entity-manager.js";
+import type { DeepObserveChange } from "@superblocksteam/library-shared/types";
+type IChange = DeepObserveChange;
+type ChangeWithRelatedObject = IChange & {
+    relatedEntity?: Entity;
+};
+export type ObserveListener<T> = (change: ChangeWithRelatedObject, path: string, root: T) => void;
+/**
+ * Given an object, deeply observes the given object.
+ * It is like `observe` from mobx, but applied recursively, including all future children.
+ *
+ * Note that the given object cannot ever contain cycles and should be a tree.
+ *
+ * As benefit: path and root will be provided in the callback, so the signature of the listener is
+ * (change, path, root) => void
+ *
+ * The returned disposer can be invoked to clean up the listener
+ *
+ * deepObserve cannot be used on computed values.
+ *
+ * @example
+ * const disposer = deepObserve(target, (change, path) => {
+ *    console.dir(change)
+ * })
+ */
+export declare function deepObserve<T>(target: T, listener: ObserveListener<T>): () => void;
+export {};

package/dist-types/lib/internal-details/lib/evaluator/entity-manager.d.ts

@@ -0,0 +1,83 @@
+import { type SbElement, type SbInstance } from "@superblocksteam/library-shared/types";
+import { type Name } from "./names.js";
+import type { IEntityManager, Executable, SingleInputProp, InternalScope, ScopedState, ScopeId, Entity, InputProp } from "./base-entity-manager.js";
+import type { ObserveListener } from "./deep-observe.js";
+import type { ValidateFn } from "../../../user-facing/properties-panel/validators.js";
+import type { ComponentRegistry } from "../features/component-registry.js";
+export declare const GLOBAL_SCOPE_ID = "Global";
+export declare class EntityManager implements IEntityManager {
+    readonly componentRegistry: ComponentRegistry;
+    private state;
+    private atoms;
+    private dirComputeEngine;
+    private evalComputeEngine;
+    constructor(componentRegistry: ComponentRegistry, options?: {
+        devtools?: boolean;
+    });
+    getEntity(ScopeId: string, name: Name): Entity;
+    getEntityById(scopeId: string, id: SbInstance): Entity;
+    getState(scopeId: string): ScopedState;
+    getScopeName(scopeId: string): string;
+    get getFullState(): Record<string, Entity>;
+    private getAccessibleScopes;
+    getScope(scopeId: string): InternalScope;
+    private getPossibleScope;
+    createScope(params: {
+        name?: string;
+        parentScopeId?: string;
+        scopeId?: string;
+    }): string;
+    deleteScope(params: {
+        scopeId: ScopeId;
+    }): void;
+    createEntity(params: {
+        scopeId: ScopeId;
+        name: Name;
+        props: Record<string, InputProp>;
+        type: string;
+        instanceId?: SbInstance;
+        sourceId?: SbElement;
+    }): Name;
+    private createEntityStructure;
+    private addProperty;
+    deleteEntity(params: {
+        name: Name;
+        scopeId: string;
+    }): void;
+    deleteEntityById(params: {
+        scopeId: string;
+        entityId: string;
+    }): void;
+    resetEntity(params: {
+        scopeId: string;
+        name: Name;
+        key?: string;
+    }): void;
+    updateEntity(params: {
+        scopeId: string;
+        name: Name;
+        instanceId?: SbInstance;
+        props: Record<string, InputProp>;
+    }): void;
+    private addMissingProps;
+    renameEntity(params: {
+        scopeId: ScopeId;
+        instanceId: SbInstance;
+        newName: Name;
+        isDuplicate: boolean;
+    }): void;
+    runCode<ARGS extends any[] = any[]>(params: {
+        scopeId: string;
+        name: Name;
+        func: Executable;
+        args?: ARGS;
+    }): void;
+    computeValue<T>(params: {
+        scopeId: ScopeId;
+        name: Name;
+        value: SingleInputProp<T>;
+        validator?: ValidateFn<T>;
+    }): T;
+    private getOrCreateAtom;
+    observeScope(scopeId: string, listener: ObserveListener<InternalScope>): () => void;
+}

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

@@ -0,0 +1,16 @@
+export declare const EntityType: {
+    readonly API: "API";
+    readonly Button: "Button";
+    readonly Text: "Text";
+    readonly Image: "Image";
+    readonly Container: "Container";
+    readonly Grid: "Grid";
+    readonly Input: "Input";
+    readonly Checkbox: "Checkbox";
+    readonly Table: "Table";
+    readonly Switch: "Switch";
+    readonly Dropdown: "Dropdown";
+    readonly Modal: "Modal";
+    readonly Dialog: "Dialog";
+};
+export type EntityType = (typeof EntityType)[keyof typeof EntityType];

package/dist-types/lib/internal-details/lib/evaluator/lazy-function.d.ts

@@ -0,0 +1,7 @@
+declare const lazyFunctionSymbol: unique symbol;
+export type LazyFunction = ((...args: unknown[]) => unknown) & {
+    [lazyFunctionSymbol]: true;
+};
+export declare const isLazyFunction: (value: unknown) => value is LazyFunction;
+export declare const LazyFunction: (source: string) => LazyFunction;
+export {};

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

@@ -0,0 +1,7 @@
+export type Name = {
+    value: string;
+    isAnonymous: boolean;
+};
+export declare const getName: (name?: string) => Name;
+export declare const isName: (name: any) => name is Name;
+export declare const isNameEqual: (a: Name, b: Name) => boolean;

package/dist-types/lib/internal-details/lib/evaluator/pretty-print-function.d.ts

@@ -0,0 +1,2 @@
+import type { EntityDerivedProp } from "./base-entity-manager.js";
+export declare const prettyPrintFunction: (func: EntityDerivedProp, args: any[]) => string;