@superblocksteam/library 2.0.33 → 2.0.34-next.1

package/dist-types/edit-mode/features/interaction-layer-manager.d.ts

@@ -0,0 +1,23 @@
+import type { SbElement, SbInstance } from "@superblocksteam/library-shared/types";
+declare class InteractionLayerManager {
+    /**
+     * The id of the root element that is currently being interacted with
+     * the root can be Page, Modal or Slideout
+     * If set to undefined, the interaction layer will be the Page
+     * if set to the detached component id, the inteactoin layer will be disabled on the page
+     */
+    activeRootInstanceId: SbInstance | undefined;
+    sourceIdElements: Map<`I-${string}`, {
+        sourceId: SbElement;
+        element: HTMLElement;
+    }>;
+    constructor();
+    setActiveRootInstanceId(rootInstanceId: SbInstance | undefined): void;
+    setSourceIdElement(el: HTMLElement, sourceId: SbElement): undefined | SbInstance;
+    removeSourceIdElement(instanceId: SbInstance): void;
+    getSourceIdElements(sourceId: SbElement): Array<{
+        element: HTMLElement;
+        instanceId: SbInstance;
+    }>;
+}
+export default InteractionLayerManager;

package/dist-types/edit-mode/features/operation-store.d.ts

@@ -0,0 +1,64 @@
+import type { CreateRequest, DeleteRequest, EditOperationPayload, EditOperations, EditOperationType, PropertyInfo, ReparentRequest, SbElement, SetPropertiesRequest, SetPropertyRequest, SourceLocation } from "@superblocksteam/library-shared/types";
+type OptimisticOperation<P> = {
+    type: keyof EditOperations;
+    payload: P;
+    id: string;
+    callback?: () => void;
+};
+export type ReparentTransaction = OptimisticOperation<ReparentRequest>;
+type SetPropertiesTransaction = OptimisticOperation<SetPropertiesRequest>;
+type SetPropertyTransaction = OptimisticOperation<SetPropertyRequest>;
+type CreateComponentTransaction = OptimisticOperation<CreateRequest>;
+type DeleteComponentsTransaction = OptimisticOperation<DeleteRequest>;
+type PendingTransaction = ReparentTransaction | SetPropertiesTransaction | SetPropertyTransaction | CreateComponentTransaction | DeleteComponentsTransaction;
+declare class OperationManager {
+    private pendingTransactions;
+    private waitingForBatch;
+    private batchOperations;
+    private batchOperationTransactionId;
+    visibleSourceIds: string[];
+    constructor();
+    get allPendingTransactions(): PendingTransaction[];
+    get pendingReparentOperations(): ReparentTransaction[];
+    get pendingDeleteOperations(): DeleteComponentsTransaction[];
+    get pendingSetPropertiesOperations(): SetPropertiesTransaction[];
+    get hasPendingOperations(): boolean;
+    get allNames(): never[];
+    private executeOrAddToBatch;
+    private addPendingTransaction;
+    clearPendingTransactions(transactionIds: string[]): void;
+    batchUpdate(performOperations: () => void): void;
+    createComponent(payload: CreateRequest): void;
+    dropComponent(action: {
+        from: {
+            source: SourceLocation;
+        };
+        to: {
+            source: SourceLocation;
+        };
+        propsToChange?: Record<string, PropertyInfo>;
+    }): void;
+    deleteComponents(sourceIds: SbElement[]): void;
+    acknowledgeEditOperation(operation: EditOperationPayload<EditOperationType>): void;
+    writeRuntimeProperties(sourceId: SbElement, transactionId: string, updates: Record<string, PropertyInfo<unknown>>): void;
+    setWidgetProperties({ sourceId, properties, callback, }: {
+        sourceId: SbElement;
+        properties: Record<string, PropertyInfo<unknown>>;
+        callback?: () => void;
+    }): void;
+    setWidgetProperty({ sourceId, property, value, callback, }: {
+        sourceId: SbElement;
+        property: string;
+        value: PropertyInfo<unknown>;
+        callback?: () => void;
+    }): void;
+    renameWidget(params: {
+        sourceId: SbElement;
+        newName: string;
+        renameInAst?: boolean;
+    }): void;
+    ensureFilesSynced(): Promise<void>;
+    generateSourceId(): `SB-${string}`;
+    private canDeleteComponents;
+}
+export default OperationManager;

package/dist-types/edit-mode/features/properties-panel-manager.d.ts

@@ -0,0 +1,45 @@
+import { type PropertyInfo, type SbElement, type SbInstance } from "@superblocksteam/library-shared/types";
+import type { EditStore } from "../edit-store.js";
+import type RuntimeEntitiesManager from "./runtime-entities-manager.js";
+import type { IEntityManager } from "../../lib/internal-details/lib/evaluator/base-entity-manager.js";
+import type { ComponentRegistry } from "../../lib/internal-details/lib/features/component-registry.js";
+import type { Prop, PropertiesDefinition } from "../../lib/user-facing/properties-panel/props-builder.js";
+import type { PropertiesPanelDefinition } from "@superblocksteam/library-shared/props";
+declare class PropertiesPanelManager {
+    readonly editStore: EditStore;
+    readonly runtimeEntitiesManager: RuntimeEntitiesManager;
+    readonly entityManager: IEntityManager;
+    readonly componentsManager: ComponentRegistry;
+    private propertiesDefinitions;
+    private propertiesPanelTrackerDisposer;
+    private nonDynamicPropertyPanels;
+    private _propertyLookupCache;
+    private removeHotReloadListener;
+    constructor(editStore: EditStore, runtimeEntitiesManager: RuntimeEntitiesManager, entityManager: IEntityManager, componentsManager: ComponentRegistry);
+    getPropertiesPanel(scopeId: string, instanceId: SbInstance): PropertiesPanelDefinition;
+    trackPropertiesPanel(scopeId: string, instanceId: SbInstance, sourceId: string): void;
+    untrackPropertiesPanel(): void;
+    getPropertiesDefinition(type: string): PropertiesDefinition | undefined;
+    setPropertiesDefinition(widgetType: string, propertiesDefinition: PropertiesDefinition): void;
+    updatePropertiesDefinitionForType(type: string): void;
+    getNonDynamicPropertiesPanels(): {
+        [k: string]: PropertiesPanelDefinition;
+    };
+    computeSideEffectsForPropertyUpdate(payload: {
+        sourceId: SbElement;
+        updates: Record<string, PropertyInfo<unknown>>;
+    }): Record<`SB-${string}`, {
+        props?: Record<string, PropertyInfo<unknown>>;
+        meta?: Record<string, unknown>;
+    }>;
+    private cachedPropertyLookupForType;
+    getPropertyForPath(widgetType: string, path: string): Prop<any, any, undefined> | null;
+    /**
+     * When a custom component's source code is updated, we want to update the properties definition for that component.
+     * In order to do that, we need to listen to vite's hot reload events. We can't put import.meta.hot calls in the library
+     * because Vite just compiled all of those out in library builds, so we inject a listener from the plugin instead.
+     * https://github.com/vitejs/vite/blob/v6.2/packages/vite/src/node/plugins/define.ts#L37
+     */
+    private attachHotReloadListener;
+}
+export default PropertiesPanelManager;

package/dist-types/edit-mode/features/resizing-store.d.ts

@@ -0,0 +1,54 @@
+import { Dim } from "@superblocksteam/library-shared";
+import type { RootStore } from "../../lib/internal-details/lib/root-store.js";
+import type { SbElement, SbInstance, Padding } from "@superblocksteam/library-shared/types";
+type GU = {
+    xGU: number;
+    yGU: number;
+    widthGU: number;
+    heightGU: number;
+};
+type ResizeState = {
+    instanceId: SbInstance;
+    sourceId: SbElement;
+    dragStartX: number;
+    dragStartY: number;
+    start: {
+        width: number;
+        height: number;
+        marginLeft: number;
+        marginTop: number;
+    };
+    resizedPosition: string;
+    widthToUpdate: Dim | null;
+    marginLeftToUpdate: Dim | null;
+    heightToUpdate: Dim | null;
+    marginTopToUpdate: Dim | null;
+    gridUnitWidth: number;
+    gridUnitHeight: number;
+    potentialCollisions: Record<SbInstance, GU>;
+    widgetGU: GU | null;
+    isApplyingResize: boolean;
+    parentPadding?: Padding;
+};
+export declare class ResizingManager {
+    private root;
+    private _activeResizes;
+    constructor(root: RootStore);
+    get activeResize(): ResizeState | null | undefined;
+    startResizing(dragStartX: number, dragStartY: number, instanceId: SbInstance, position: string): void;
+    private calculatePotentialCollisions;
+    private calculateDimension;
+    private handleResizeDimension;
+    private isColliding;
+    resizeWidget(currentX: number, currentY: number, instanceId: SbInstance, canResizeWidth: boolean, canResizeHeight: boolean): void;
+    pendingResize(sourceId: SbElement): {
+        width: Dim | null;
+        height: Dim | null;
+        marginLeft: Dim | null;
+        marginTop: Dim | null;
+    } | null;
+    get hasAnyPendingResize(): boolean;
+    get pendingResizes(): ResizeState[];
+    applyResize(instanceId: SbInstance): void;
+}
+export {};

package/dist-types/edit-mode/features/runtime-entities-manager.d.ts

@@ -0,0 +1,95 @@
+import RuntimeWidgetsManager from "./runtime-widgets-manager.js";
+import type { ChildElement, RuntimeWidgetMeta } from "./runtime-widgets-manager.js";
+import type { IEntityManager } from "../../lib/internal-details/lib/evaluator/base-entity-manager.js";
+import type { IdentifierInfo, NameManager } from "../../lib/internal-details/lib/features/name-manager.js";
+import type { CreateRequest, DeleteRequest, SbElement, SbInstance } from "@superblocksteam/library-shared/types";
+declare class RuntimeEntitiesManager {
+    readonly nameManager: NameManager;
+    readonly entityManager: IEntityManager;
+    widgets: RuntimeWidgetsManager;
+    entitiesWithLocalBindings: Set<string>;
+    constructor(nameManager: NameManager, entityManager: IEntityManager);
+    processRootWidget(params: {
+        rootIdentifier: IdentifierInfo;
+        rootProps: Record<string, unknown>;
+        rootType: string;
+        fallbackScopeId: string;
+        isInCustomComponent: boolean;
+        parentInstanceId?: SbInstance;
+    }): void;
+    addOptimisticCreateWidget(createRequest: CreateRequest): void;
+    private getOptimisticWidgetMeta;
+    getEditorWidgetMeta(instanceId: SbInstance): RuntimeWidgetMeta | undefined;
+    getEditorWidgetSourceId(instanceId: SbInstance): `SB-${string}` | undefined;
+    getEditorWidgetScopeId(instanceId: SbInstance): string | undefined;
+    getAnyEditorWidgetMeta(sourceId: SbElement): RuntimeWidgetMeta | undefined;
+    getEditorWidgetName(instanceId: SbInstance): string | undefined;
+    getEditorWidgetType(instanceId: SbInstance): string | undefined;
+    getEditorWidgetChildrenMeta(instanceId: SbInstance): Array<RuntimeWidgetMeta>;
+    setEntitiesWithLocalBindings(entities: string[]): void;
+    doesEntityHaveLocalBindings(entity: SbInstance): boolean;
+    private getOptimisticWidgetChildrenIds;
+    private getParentSourceId;
+    private get relevantChildrenOperationsMap();
+    private getChildrenWithOptimisticUpdates;
+    getEditorWidgetChildren(instanceId: SbInstance): ChildElement[];
+    hasEditOperationsPending(): boolean;
+    getPendingOperations(): ({
+        instanceId: SbInstance;
+        sourceId: SbElement;
+        dragStartX: number;
+        dragStartY: number;
+        start: {
+            width: number;
+            height: number;
+            marginLeft: number;
+            marginTop: number;
+        };
+        resizedPosition: string;
+        widthToUpdate: import("@superblocksteam/library-shared").Dim | null;
+        marginLeftToUpdate: import("@superblocksteam/library-shared").Dim | null;
+        heightToUpdate: import("@superblocksteam/library-shared").Dim | null;
+        marginTopToUpdate: import("@superblocksteam/library-shared").Dim | null;
+        gridUnitWidth: number;
+        gridUnitHeight: number;
+        potentialCollisions: Record<SbInstance, {
+            xGU: number;
+            yGU: number;
+            widthGU: number;
+            heightGU: number;
+        }>;
+        widgetGU: {
+            xGU: number;
+            yGU: number;
+            widthGU: number;
+            heightGU: number;
+        } | null;
+        isApplyingResize: boolean;
+        parentPadding?: import("@superblocksteam/library-shared/types").Padding;
+    } | (import("./operation-store.js").ReparentTransaction | {
+        type: keyof import("@superblocksteam/library-shared/types").EditOperations;
+        payload: import("@superblocksteam/library-shared/types").SetPropertiesRequest;
+        id: string;
+        callback?: () => void;
+    } | {
+        type: keyof import("@superblocksteam/library-shared/types").EditOperations;
+        payload: import("@superblocksteam/library-shared/types").SetPropertyRequest;
+        id: string;
+        callback?: () => void;
+    } | {
+        type: keyof import("@superblocksteam/library-shared/types").EditOperations;
+        payload: CreateRequest;
+        id: string;
+        callback?: () => void;
+    } | {
+        type: keyof import("@superblocksteam/library-shared/types").EditOperations;
+        payload: DeleteRequest;
+        id: string;
+        callback?: () => void;
+    }))[];
+    getScopeIdForSourceId(sourceId: SbElement): string | undefined;
+    applySideEffects(changes: Record<string, Record<string, unknown>>, scopeId: string): void;
+    isChildOf(childId: SbInstance, parentId: SbInstance): boolean;
+    getClosestAncestorByType(id: SbInstance, type: string): RuntimeWidgetMeta | undefined;
+}
+export default RuntimeEntitiesManager;

package/dist-types/edit-mode/features/runtime-widgets-manager.d.ts

@@ -0,0 +1,59 @@
+import React from "react";
+import type { Name } from "../../lib/internal-details/lib/evaluator/names.js";
+import type { IdentifierInfo, NameManager } from "../../lib/internal-details/lib/features/name-manager.js";
+import type { CreateRequest, SbElement, SbInstance } from "@superblocksteam/library-shared/types";
+import type { ReactNode } from "react";
+export type ChildFunction = React.FunctionComponent;
+export type ChildElement = {
+    isSupportedElement: true;
+    isSbComponent: boolean;
+    value: SbInstance;
+} | {
+    isSupportedElement: false;
+    isSbComponent: false;
+    value: ChildFunction;
+};
+export type RuntimeWidgetMeta = {
+    instanceId: SbInstance;
+    sourceId: SbElement;
+    rootInstanceId: SbInstance;
+    isSbComponent: boolean;
+    isInCustomComponent: boolean;
+    isOptimistic: boolean;
+    node?: ReactNode;
+    scopeId?: string;
+    type?: string;
+    name?: Name;
+    props?: Record<string, unknown>;
+    children?: ChildElement[];
+    parentInstanceId?: SbInstance;
+    isUnmounted?: boolean;
+};
+declare class RuntimeWidgetsManager {
+    readonly nameManager: NameManager;
+    private widgets;
+    private sourceIdCount;
+    private sourceToInstanceIdSample;
+    constructor(nameManager: NameManager);
+    private setWidgetMeta;
+    getAnyInstanceIdForSourceId(sourceId: SbElement): `I-${string}`;
+    getAllInstanceIdsForSourceId(sourceId: SbElement): `I-${string}`[];
+    getSourceIdForInstanceId(instanceId: SbInstance): `SB-${string}`;
+    processRoot(params: {
+        rootIdentifier: IdentifierInfo;
+        rootProps: Record<string, unknown>;
+        rootType: string;
+        isInCustomComponent: boolean;
+        fallbackScopeId: string;
+        parentInstanceId?: SbInstance;
+    }): void;
+    addWidgetFromPayload(details: {
+        rootInstanceId: SbInstance;
+        parentInstanceId: SbInstance;
+    }, createRequest: CreateRequest): void;
+    getMeta(id: SbInstance): RuntimeWidgetMeta | undefined;
+    getSourceIdCount(sourceId: SbElement): number;
+    isChildOf(childId: SbInstance, parentId: SbInstance): boolean;
+    getClosestAncestorByType(instanceId: SbInstance, type: string): RuntimeWidgetMeta | undefined;
+}
+export default RuntimeWidgetsManager;

package/dist-types/edit-mode/features/ui-store.d.ts

@@ -0,0 +1,49 @@
+import { DragAndDropManager } from "./drag-and-drop-store.js";
+import { ResizingManager } from "./resizing-store.js";
+import type { RootStore } from "../../lib/internal-details/lib/root-store.js";
+import type { EditStore } from "../edit-store.js";
+import type { SbElement, SbInstance } from "@superblocksteam/library-shared/types";
+declare class UIStore {
+    readonly root: RootStore;
+    readonly editStore: EditStore;
+    dnd: DragAndDropManager;
+    resizing: ResizingManager;
+    private _selectedSourceIds;
+    private _selectedInstanceIds;
+    private _focusedSourceId;
+    private _focusedInstanceId;
+    private _rootInstanceData;
+    private newComponentSelectPromise;
+    constructor(root: RootStore, editStore: EditStore);
+    isSourceSelected(sourceId: SbElement): boolean;
+    isInstanceSelected(instanceId: SbInstance): boolean;
+    isSourceFocused(sourceId: SbElement): boolean;
+    isInstanceFocused(instanceId: SbInstance): boolean;
+    getSelectedSourceIds(): SbElement[];
+    getSelectedInstanceIds(): SbInstance[];
+    getRootDataByInstanceId(instanceId: SbInstance): {
+        sourceId: SbElement;
+        isPageRoot: boolean;
+    } | undefined;
+    addRootInstanceId(instanceId: SbInstance, sourceId: SbElement, isPageRoot: boolean): void;
+    removeRootInstanceId(instanceId: SbInstance): void;
+    isInstancePageRoot(instanceId: SbInstance): boolean | undefined;
+    private get focusedSourceId();
+    private get focusedInstanceId();
+    getFocusedSourceId(): SbElement | null;
+    getFocusedInstanceId(): SbInstance | null;
+    setSelectedSourceIds(sourceIds: SbElement[]): void;
+    setSelectedInstanceIds(ids: SbInstance[]): void;
+    setFocusedInstanceId(instanceId: SbInstance | null): void;
+    setFocusedSourceId(sourceId: SbElement | null): void;
+    selectWidget(instanceId: SbInstance | null, _addToSelection?: boolean): void;
+    /**
+     * This is cursed because component selection actually needs to be done by instance ids, but
+     * instance IDs are only guaranteed to be stable after the component is rendered, while source IDs
+     * are assigned by the source tracker.
+     *
+     * If _any_ other selection comes in before we select something, we will cancel this reaction
+     */
+    selectNewComponentBySourceId(sourceId: SbElement, instanceIdsToIgnore?: Set<`I-${string}`>): Promise<void>;
+}
+export default UIStore;

package/dist-types/edit-mode/get-edit-store.d.ts

@@ -0,0 +1,6 @@
+import type { EditStore } from "./edit-store.js";
+/**
+ * Get the global EditStore instance
+ * @returns The EditStore instance
+ */
+export declare function getEditStore(): EditStore;

package/dist-types/edit-mode/hooks/use-register-source-element.d.ts

@@ -0,0 +1,2 @@
+import type { SbElement } from "@superblocksteam/library-shared/types";
+export declare function useRegisterSourceElement(sourceId: SbElement): (element: HTMLElement | null) => void;

package/dist-types/edit-mode/identifier-context.d.ts

@@ -0,0 +1,6 @@
+import type { IdentifierInfo } from "../lib/internal-details/lib/features/name-manager";
+export declare function useParentIdentifier(): IdentifierInfo | null | undefined;
+export declare function ParentIdentifierProvider({ identifier, children, }: {
+    identifier: IdentifierInfo;
+    children: React.ReactNode;
+}): import("react").JSX.Element;

package/dist-types/edit-mode/iframe-wrappers.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export declare const FullPageSpinner: import("styled-components").StyledComponent<React.FC<import("@blueprintjs/core").SpinnerProps<HTMLElement>>, any, {}, never>;
+declare const Auth0Wrapper: (props: React.PropsWithChildren) => React.JSX.Element;
+declare const EmbedWrapper: (props: React.PropsWithChildren) => React.JSX.Element;
+export { EmbedWrapper, Auth0Wrapper };

package/dist-types/edit-mode/import-error-notification.d.ts

@@ -0,0 +1 @@
+export declare const ImportErrorNotification: import("react").FunctionComponent<object>;

package/dist-types/edit-mode/interaction-layer/interaction-add-section-button.d.ts

@@ -0,0 +1,4 @@
+import type { SbInstance } from "@superblocksteam/library-shared/types";
+export declare const AddSectionButtons: ({ sectionInstanceId, }: {
+    sectionInstanceId: SbInstance;
+}) => import("react").JSX.Element | null;

package/dist-types/edit-mode/interaction-layer/interaction-layer.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import type { SbInstance } from "@superblocksteam/library-shared/types";
+export type RootType = "Page" | "Modal" | "Slideout";
+declare const InteractionLayer: ((props: {
+    rootType: RootType;
+    rootInstanceId: SbInstance;
+    rootName?: string;
+}) => React.JSX.Element | null) & {
+    displayName: string;
+};
+export default InteractionLayer;

package/dist-types/edit-mode/interaction-layer/interaction-rect-actions.d.ts

@@ -0,0 +1,9 @@
+import { type SbInstance } from "@superblocksteam/library-shared/types";
+export declare function InteractionRectActions(props: {
+    instanceId: SbInstance;
+    displayName: string;
+    anyIsDragging: boolean;
+    enableDragging: boolean;
+    type: "SELECTED" | "FOCUSED" | "ERROR" | "TARGETED";
+    isVisible?: boolean;
+}): import("react").JSX.Element | null;

package/dist-types/edit-mode/interaction-layer/interaction-rect-handles.d.ts

@@ -0,0 +1,7 @@
+import type { SbInstance } from "@superblocksteam/library-shared/types";
+export declare const NotifierTooltipBody: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const InteractionRectHandles: (props: {
+    instanceId: SbInstance;
+    isDragging: boolean;
+    selectionType: "SELECTED" | "FOCUSED" | "ERROR" | "TARGETED";
+}) => import("react").JSX.Element;

package/dist-types/edit-mode/interaction-layer/interaction-rect-name-pill.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import type { SbInstance } from "@superblocksteam/library-shared/types";
+declare const NamePill: ((props: {
+    instanceId: SbInstance;
+    displayName: string;
+    anyIsDragging: boolean;
+    enableDragging: boolean;
+    type: "SELECTED" | "FOCUSED" | "ERROR" | "TARGETED";
+    isVisible?: boolean;
+}) => React.JSX.Element) & {
+    displayName: string;
+};
+export default NamePill;

package/dist-types/edit-mode/interaction-layer/interaction-rect.d.ts

@@ -0,0 +1,49 @@
+import { AiContextMode, type SbElement, type SbInstance } from "@superblocksteam/library-shared/types";
+import React from "react";
+import type { RootType } from "./interaction-layer.jsx";
+import type { IdentifierInfo } from "../../lib/internal-details/lib/features/name-manager.js";
+type SelectionInfo = {
+    sourceId: SbElement;
+    instanceId: SbInstance;
+    displayName: string;
+    selectionType: "SELECTED" | "FOCUSED" | "TARGETED";
+    type: string | undefined;
+    isVisible?: boolean;
+};
+export declare const isWidgetInCurrentLayer: ({ instanceId, rootType, rootInstanceId, }: {
+    instanceId: SbInstance;
+    rootType: RootType;
+    rootInstanceId: SbInstance;
+}) => boolean;
+export declare const useWidgetErrors: (params: {
+    widgetScopesToNamesToIds: Record<string, Record<string, Record<SbInstance, IdentifierInfo>>>;
+    rootType: RootType;
+    rootInstanceId: SbInstance;
+    scopeId: string;
+}) => Record<SbInstance, {
+    name: string;
+    error: string;
+}>;
+export declare const useSelectionElements: (params: {
+    focusedSourceId: SbElement | null;
+    selectedSourceIds: SbElement[];
+    focusedInstanceId: SbInstance | null;
+    selectedInstanceIds: SbInstance[];
+    targetedSourceIds: SbElement[];
+    rootType: RootType;
+    rootId: SbInstance;
+    aiContextMode: AiContextMode;
+}) => SelectionInfo[];
+export declare const InteractionRectTargetBorder: ({ instanceId, }: {
+    instanceId: SbInstance;
+}) => React.JSX.Element;
+export declare const InteractionRect: (props: {
+    displayName: string;
+    isDragging: boolean;
+    instanceId: SbInstance;
+    selectionType: "SELECTED" | "FOCUSED" | "ERROR" | "TARGETED";
+    hideRectBorder?: boolean;
+    isVisible?: boolean;
+    type?: string;
+}) => React.JSX.Element;
+export {};

package/dist-types/edit-mode/interaction-utils.d.ts

@@ -0,0 +1,8 @@
+import type { SbInstance } from "@superblocksteam/library-shared/types";
+export declare const getBoundingBoxForWidget: (instanceId: SbInstance) => DOMRect | undefined;
+export declare const getFirstInstanceElement: (element: HTMLElement) => {
+    element: HTMLElement;
+    instanceId: SbInstance;
+} | null;
+export declare const getWidgetNode: (instanceId: SbInstance) => HTMLElement | null;
+export declare const getIsComponentInInteractionLayer: (instanceId: SbInstance | null) => boolean | null;

package/dist-types/edit-mode/mobx-sync/create-patch.d.ts

@@ -0,0 +1,2 @@
+import type { MobXPatch } from "@superblocksteam/library-shared/types";
+export declare const microPatches: (oldValue: any, newValue: any, baseStr: string) => MobXPatch[];

package/dist-types/edit-mode/mobx-sync/create-patch.test.d.ts

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

package/dist-types/edit-mode/mobx-sync/deep-observe.d.ts

@@ -0,0 +1,24 @@
+import type { IObjectDidChange, IArrayDidChange, IMapDidChange } from "mobx";
+export type IDisposer = () => void;
+type IChange = IObjectDidChange | IArrayDidChange | IMapDidChange;
+export type ObserveListener<T> = (change: IChange, 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 = any>(target: T, listener: ObserveListener<T>): IDisposer;
+export {};

package/dist-types/edit-mode/mobx-sync/mobx-editor-sync.d.ts

@@ -0,0 +1,23 @@
+import type { KeyToState } from "@superblocksteam/library-shared/types";
+export interface MobXEditorSyncOptions<SID extends keyof KeyToState = keyof KeyToState, OUTPUT extends KeyToState[SID] = KeyToState[SID], STORE = OUTPUT> {
+    storeId: SID & string;
+    store: STORE;
+    /**
+     * A function that takes the store and returns a view/projection of the store.
+     * This is useful for syncing only a subset of the store in a different shape.
+     */
+    projection?: (store: STORE) => OUTPUT;
+    /**
+     * When provided, only patches under these keys are forwarded.
+     * Other changes are dropped.
+     */
+    keys?: Record<keyof OUTPUT, true>;
+    /**
+     * Debounce time in milliseconds.
+     */
+    debounce?: number;
+}
+/**
+ * Syncs a mobx store to the editor automatically through postmessage
+ */
+export declare function startEditorSync<SID extends keyof KeyToState = keyof KeyToState, OUTPUT extends KeyToState[SID] = KeyToState[SID], STORE = any>(options: MobXEditorSyncOptions<SID, OUTPUT, STORE>): () => void;

package/dist-types/edit-mode/mobx-sync/mobx-editor-sync.test.d.ts

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

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

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

package/dist-types/edit-mode/properties.d.ts

@@ -0,0 +1,13 @@
+import { type Name } from "../lib/internal-details/lib/evaluator/names.js";
+/**
+ * Gets the actual value from a PropertyInfo object.
+ * This will parse the value based on the type of property.
+ * @param property - The property to get the value from.
+ * @returns The parsed value of the property.
+ */
+export declare function getPropertyValue({ entityKey, property, name, scopeId, }: {
+    property: unknown;
+    entityKey?: string;
+    name?: Name;
+    scopeId?: string;
+}): unknown;

package/dist-types/edit-mode/resize-capabilities.d.ts

@@ -0,0 +1,5 @@
+import type { SbInstance } from "@superblocksteam/library-shared/types";
+export declare const useResizeCapabilities: (instanceId: SbInstance) => {
+    canResizeWidth: boolean;
+    canResizeHeight: boolean;
+};

package/dist-types/edit-mode/right-click-menu/right-click-menu.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import type { SbElement } from "@superblocksteam/library-shared/types";
+import type { ReactNode } from "react";
+interface RightClickMenuProps {
+    children?: ReactNode;
+    componentName: string;
+    sourceId: SbElement;
+    scopeName: string;
+    type: string;
+}
+declare const RightClickMenuWrapper: React.FC<RightClickMenuProps & {
+    disabled?: boolean;
+}>;
+export default RightClickMenuWrapper;