@superblocksteam/library 2.0.28 → 2.0.29-next.0

package/dist-types/app-internal.d.ts

@@ -0,0 +1,4 @@
+import "./lib/style.css";
+import "@blueprintjs/core/lib/css/blueprint.css";
+declare function App(): import("react").JSX.Element;
+export default App;

package/dist-types/docs-utils/generate-docs-utils.d.ts

@@ -0,0 +1,42 @@
+import type { Section } from "../lib/user-facing/properties-panel/props-builder.js";
+/**
+ * Check if a property should be excluded from documentation generation
+ */
+export declare function isPropertyExcluded(componentName: string, propertyName: string): boolean;
+/**
+ * Check if a property is readable (has .readable() or .readAndWrite())
+ */
+export declare function isPropertyReadable(prop: any): boolean;
+/**
+ * Check if a property is writable (has .readAndWrite())
+ */
+export declare function isPropertyWritable(prop: any): boolean;
+/**
+ * Check if a property is an event property (has type "event")
+ */
+export declare function isPropertyEvent(prop: any): boolean;
+/**
+ * Get custom type definition for a property, if one exists
+ */
+export declare function getCustomPropertyType(componentName: string, propertyName: string): string | undefined;
+export declare function formatDefaultValue(value: any): string | undefined;
+export declare function getDescription(prop: any): string | undefined;
+export declare function getDefaultValue(prop: any, propName: string): any;
+export declare function guessTypeString(prop: any, key: string, componentName?: string): string;
+export declare function generateInterfaceFromNestedProps(nestedProps: any, interfaceName: string, componentName?: string): string;
+export declare function getRecordValueType(prop: any, key: string, componentName?: string): string;
+export type PropContainer = {
+    name: string;
+    type: string;
+    defaultValue: any;
+    isReadonly?: boolean;
+    description?: string;
+};
+export declare function generateComponentDocs(component: {
+    name: string;
+    props: Record<string, Section<any>>;
+}): {
+    lines: string[];
+    derivedProps: PropContainer[];
+    metaProps: PropContainer[];
+};

package/dist-types/docs-utils/generate-docs.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S pnpm tsx
+export {};

package/dist-types/docs-utils/generate-docs.test.d.ts

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

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

@@ -0,0 +1,60 @@
+import type { FromChildToParentMessageTypesMap } from "../lib/index.js";
+import type { StreamEvent, RouteInfo } from "../lib/internal-details/lib/types.js";
+import type { PropertiesPanelDefinition } from "@superblocksteam/library-shared/props";
+import type { AiContextMode, EditOperationPayload, EditOperationType, GeneratedTheme, SbElement, SbInstance, Theme } from "@superblocksteam/library-shared/types";
+export interface SuperblocksParentBridgeInterface {
+    connected(): void;
+    sendReady(): void;
+    sendNotification(type: "success" | "error" | "info" | "warning", message: string, description?: string): void;
+    selectWidgets(sourceIds: SbElement[]): void;
+    editOpRequest<T extends EditOperationType>(type: T, payload: EditOperationPayload<T>["payload"]): 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;
+    registerContextMenuClick(sourceId: SbElement, clientX: number, clientY: number): void;
+    updateRoute(routeInfo: RouteInfo): void;
+    socketError(message: string): void;
+    addComponentToAiContext(sourceId: SbElement, instanceId: SbInstance): void;
+    toggleComponentInAiContext(sourceId: SbElement, instanceId: SbInstance): void;
+    setAiContextMode(mode: AiContextMode): void;
+}
+export declare class DeployedParentBridge implements SuperblocksParentBridgeInterface {
+    navigateTo(url: string, newWindow?: boolean): void;
+    connected(): void;
+    sendReady(): void;
+    sendNotification(_type: "success" | "error" | "info" | "warning", _message: string, _description?: string): void;
+    selectWidgets(_sourceIds: SbElement[]): void;
+    editOpRequest<T extends EditOperationType>(_type: T, _payload: EditOperationPayload<T>["payload"]): 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;
+    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;
+    registerContextMenuClick(_sourceId: SbElement, _clientX: number, _clientY: number): void;
+    updateRoute(routeInfo: RouteInfo): void;
+    socketError(_message: string): void;
+    addComponentToAiContext(_sourceId: SbElement): void;
+    toggleComponentInAiContext(_sourceId: SbElement, _instanceId: SbInstance): void;
+    setAiContextMode(_mode: AiContextMode): void;
+}

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

@@ -0,0 +1,3 @@
+export declare const CollisionsLayer: (() => import("react").JSX.Element) & {
+    displayName: string;
+};

package/dist-types/edit-mode/create-component.d.ts

@@ -0,0 +1,11 @@
+import type { PropertyInfo, SbElement, SourceLocation } from "@superblocksteam/library-shared/types";
+export declare const generateUniqueName: (componentType: string) => string;
+export default function createComponent({ componentType, parent, scopeName, baseProperties, skipSecondaryComponentsCreation, // will only create the primary component. Secondary components are usually trigger components (e.g: Button that triggers the modal)
+otherComponentsUpdates, }: {
+    componentType: string;
+    parent: SourceLocation;
+    scopeName: string;
+    baseProperties?: Record<string, PropertyInfo>;
+    skipSecondaryComponentsCreation?: boolean;
+    otherComponentsUpdates?: Record<SbElement, Record<string, PropertyInfo>>;
+}): Promise<SbElement | undefined>;

package/dist-types/edit-mode/create-component.test.d.ts

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

package/dist-types/edit-mode/debug-tools.d.ts

@@ -0,0 +1,11 @@
+export declare const debugLogId: (id: string) => {
+    id: string;
+    idType: string;
+    meta: import("./features/runtime-widgets-manager.js").RuntimeWidgetMeta;
+    anyInstanceId?: undefined;
+} | {
+    id: string;
+    idType: string;
+    anyInstanceId: `I-${string}`;
+    meta: import("./features/runtime-widgets-manager.js").RuntimeWidgetMeta | undefined;
+} | undefined;

package/dist-types/edit-mode/dnd/collision-detection.d.ts

@@ -0,0 +1,3 @@
+import type { CollisionDetection } from "@dnd-kit/core";
+declare const fixCursorSnapOffset: CollisionDetection;
+export default fixCursorSnapOffset;

package/dist-types/edit-mode/dnd/dnd-provider.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const DnDProvider: (props: {
+    children: React.ReactNode;
+}) => React.JSX.Element;

package/dist-types/edit-mode/dnd/draggable-widget.d.ts

@@ -0,0 +1,7 @@
+import type { SbInstance } from "@superblocksteam/library-shared/types";
+declare const DraggableWidget: import("react").FunctionComponent<{
+    instanceId: SbInstance;
+    children: React.ReactNode;
+    disableDrag?: boolean;
+}>;
+export default DraggableWidget;

package/dist-types/edit-mode/dnd/drop-layer.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export declare const DropLayer: (() => React.JSX.Element) & {
+    displayName: string;
+};
+export default DropLayer;

package/dist-types/edit-mode/dnd/droppable-widget.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import type { SbInstance } from "@superblocksteam/library-shared/types";
+declare const DroppableWidget: ((props: {
+    instanceId: SbInstance;
+    children: React.ReactNode;
+    dropTargetRef?: React.RefObject<HTMLElement | null>;
+}) => React.JSX.Element) & {
+    displayName: string;
+};
+export default DroppableWidget;

package/dist-types/edit-mode/dnd/get-allowed-children.d.ts

@@ -0,0 +1,2 @@
+export declare const getAllowedChildrenComponentTypes: (componentType: string) => string[] | undefined;
+export declare function isNestable(componentType: string, parentType?: string): boolean;

package/dist-types/edit-mode/dnd/grid-drop.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const GridDropPreview: (() => React.JSX.Element | null) & {
+    displayName: string;
+};

package/dist-types/edit-mode/dnd/grid-store.d.ts

@@ -0,0 +1,58 @@
+import type { GridDropInfo, RectLike } from "./types.js";
+import type { RootStore } from "../../lib/internal-details/lib/root-store.js";
+import type { DragAndDropManager } from "../features/drag-and-drop-store.js";
+import type { RuntimeWidgetMeta } from "../features/runtime-widgets-manager.js";
+import type { ClientRect } from "@dnd-kit/core";
+import type { Padding } from "@superblocksteam/library-shared/types";
+type GridInfo = {
+    targetColumns: number;
+    tileWidth: number;
+    tileHeight: number;
+    targetHeightGU: number;
+    targetPadding: Padding;
+};
+export declare class GridManager {
+    private root;
+    private dnd;
+    constructor(root: RootStore, dnd: DragAndDropManager);
+    private get draggedInstanceId();
+    refreshPositionsAndGetDropConstraints(): GridDropInfo;
+    getGridInfo(runtimeWidget: RuntimeWidgetMeta, targetRect: ClientRect): GridInfo | null;
+    private get lazyTargetGridInfo();
+    private getGridPositionFromRect;
+    getGridPositionInfo({ positionRect, targetRect, targetGridInfo, includePadding, }: {
+        positionRect: RectLike<number>;
+        targetRect: ClientRect;
+        targetGridInfo: GridInfo;
+        includePadding: boolean;
+    }): {
+        xGU: number;
+        yGU: number;
+        widthGU: number;
+        heightGU: number;
+        tileWidth: number;
+        tileHeight: number;
+        targetPadding: import("@superblocksteam/library-shared/types").Spacing;
+    };
+    get lazyChildGridPositionsGU(): Record<`I-${string}`, {
+        xGU: number;
+        yGU: number;
+        widthGU: number;
+        heightGU: number;
+        tileWidth: number;
+        tileHeight: number;
+        targetPadding: import("@superblocksteam/library-shared/types").Spacing;
+    } | null>;
+    get lazyActiveRectGU(): {
+        xGU: number;
+        yGU: number;
+        widthGU: number;
+        heightGU: number;
+        tileWidth: number;
+        tileHeight: number;
+        targetPadding: import("@superblocksteam/library-shared/types").Spacing;
+    } | null;
+    get lazyIsFreePos(): boolean;
+    adjustDragRectForCollisions(collidingRect: ClientRect | null): ClientRect | null;
+}
+export {};

package/dist-types/edit-mode/dnd/grid-utils.d.ts

@@ -0,0 +1,8 @@
+import type { GURectLike } from "./types.js";
+export declare const isRectIntersecting: (rect1: GURectLike, rect2: GURectLike) => boolean;
+export declare const isCollidingByCoordinate: (rect1: GURectLike, rect2: GURectLike) => {
+    left: boolean;
+    right: boolean;
+    top: boolean;
+    bottom: boolean;
+};

package/dist-types/edit-mode/dnd/handle-grid-drop.d.ts

@@ -0,0 +1,9 @@
+import type { GridDropInfo } from "./types.js";
+import type { SbElement, SbInstance } from "@superblocksteam/library-shared/types";
+export declare const handleGridDrop: ({ gridDropInfo, draggedId, dropTargetId, isDraggingNewComponent, newComponentType, }: {
+    gridDropInfo: GridDropInfo;
+    draggedId: SbInstance | undefined | null;
+    dropTargetId: SbInstance;
+    isDraggingNewComponent: boolean;
+    newComponentType: string | null | undefined;
+}) => Promise<SbElement | undefined>;

package/dist-types/edit-mode/dnd/handle-stack-drop.d.ts

@@ -0,0 +1,9 @@
+import type { StackDropInfo } from "./types.js";
+import type { SbElement, SbInstance } from "@superblocksteam/library-shared/types";
+export declare const handleStackDrop: ({ dropInfo, draggedId, dropTargetId, isDraggingNewComponent, newComponentType, }: {
+    dropInfo: StackDropInfo;
+    draggedId: SbInstance | undefined | null;
+    dropTargetId: SbInstance;
+    isDraggingNewComponent: boolean;
+    newComponentType: string | null | undefined;
+}) => Promise<SbElement | undefined>;

package/dist-types/edit-mode/dnd/hooks/use-component-draggable.d.ts

@@ -0,0 +1,5 @@
+import { useDraggable } from "@dnd-kit/core";
+import type { ComponentDraggableData } from "../types";
+export declare function useComponentDraggable({ instanceId, disableDrag, }: ComponentDraggableData & {
+    disableDrag: boolean;
+}): ReturnType<typeof useDraggable>;

package/dist-types/edit-mode/dnd/hooks/use-component-droppable.d.ts

@@ -0,0 +1,6 @@
+import { useDroppable } from "@dnd-kit/core";
+import type { ComponentDroppableData } from "../types";
+import "react";
+export declare function useComponentDroppable({ instanceId, rootInstanceId, depth, disabled, }: ComponentDroppableData & {
+    disabled: boolean;
+}): ReturnType<typeof useDroppable>;

package/dist-types/edit-mode/dnd/hooks/use-handle-dnd-events.d.ts

@@ -0,0 +1 @@
+export declare const useHandleDnDEvents: () => void;

package/dist-types/edit-mode/dnd/hooks/use-widget-node-ref.d.ts

@@ -0,0 +1,2 @@
+import type { SbInstance } from "@superblocksteam/library-shared/types";
+export declare const useWidgetNodeRef: (instanceId: SbInstance) => HTMLElement | null;

package/dist-types/edit-mode/dnd/new-components-drag-layer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A layer above the editor canvas that triggers the draggable preview for new components.
+ */
+export declare const NewComponentsDragLayer: (() => import("react").JSX.Element | null) & {
+    displayName: string;
+};

package/dist-types/edit-mode/dnd/stack-drop.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const StackDropPreview: (() => React.JSX.Element) & {
+    displayName: string;
+};

package/dist-types/edit-mode/dnd/stack-store.d.ts

@@ -0,0 +1,10 @@
+import type { StackDropInfo } from "./types.js";
+import type { RootStore } from "../../lib/internal-details/lib/root-store.js";
+import type { DragAndDropManager } from "../features/drag-and-drop-store.js";
+export declare class StackManager {
+    private root;
+    private dnd;
+    constructor(root: RootStore, dnd: DragAndDropManager);
+    refreshPositionsAndGetDropIndex(): StackDropInfo;
+    get lazyDropInfo(): StackDropInfo;
+}

package/dist-types/edit-mode/dnd/stack-utils.d.ts

@@ -0,0 +1,13 @@
+import type { RectLike, StackDropInfo } from "./types.js";
+import type { SbInstance } from "@superblocksteam/library-shared/types";
+export declare const computeDragInfo: (params: {
+    isVertical: boolean;
+    childrenNodes: Array<[id: SbInstance, child: RectLike<number>]>;
+    baseRect: RectLike<number>;
+    draggedItemPos: {
+        x: number;
+        y: number;
+    };
+    draggedInstance: SbInstance;
+    selectedInstances: SbInstance[];
+}) => undefined | StackDropInfo;

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

@@ -0,0 +1,45 @@
+import type { OutputItem } from "../../lib/user-facing/components/grid/calculations/calculate-constraints.js";
+import type { SbInstance } from "@superblocksteam/library-shared/types";
+export type ComponentDraggableData = {
+    instanceId: SbInstance;
+};
+export type ComponentDroppableData = {
+    instanceId: SbInstance;
+    rootInstanceId?: SbInstance;
+    depth: number;
+};
+export type RectLike<T> = {
+    top: T;
+    left: T;
+    bottom: T;
+    right: T;
+    width: T;
+    height: T;
+};
+export type StackDropInfo = {
+    insertionIndex: undefined;
+    placeholders: undefined;
+} | {
+    insertionIndex: number;
+    placeholders: StackPlaceholderPos[];
+    noopDrop: boolean;
+};
+export type StackPlaceholderPos = {
+    isActive?: boolean;
+    left: number;
+    top: number;
+    width?: number | string;
+    height?: number | string;
+};
+export type GURectLike = {
+    xGU: number;
+    yGU: number;
+    widthGU: number;
+    heightGU: number;
+};
+export type GridDropInfo = {
+    constraintsByInstanceId: Record<SbInstance, OutputItem>;
+    isValid: true;
+} | {
+    isValid: false;
+};

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

@@ -0,0 +1,42 @@
+import { type PropertyInfo } from "@superblocksteam/library-shared";
+import type { Dim } from "@superblocksteam/library-shared";
+declare const detachedComponentTypeList: readonly ["Modal", "Slideout"];
+export type DetachedComponentType = (typeof detachedComponentTypeList)[number];
+export declare const DetachedComponentTypes: Set<string>;
+export declare const isDragAndDropTypeValid: ({ draggedType, dropTargetType, dropTargetEmpty, isDraggingNewComponent, }: {
+    draggedType: string;
+    dropTargetType: string;
+    dropTargetEmpty: boolean;
+    isDraggingNewComponent: boolean;
+}) => boolean;
+export declare const isTypeDroppable: (type: string) => boolean;
+export declare const isTypeDraggable: (type: string) => boolean;
+export declare const isContentDraggable: (type: string) => boolean;
+/**
+ * Uses `allowedChildren` config from the ChildrenProp to determine if the component should be wrapped.
+ * @param type - the type of the component being created
+ * @param parentType - the type of the parent component
+ * @returns
+ *  - [false] if the component should not be wrapped
+ *  - [true, wrapInType] if the component should be wrapped in the given type
+ */
+export declare function shouldWrapComponent(type: string, parentType: string | undefined): [false] | [true, string];
+export declare const filterSafeStackDimensionProperties: (existingProps: {
+    width?: Dim;
+    height?: Dim;
+    size?: Dim;
+}) => {
+    width?: PropertyInfo;
+    height?: PropertyInfo;
+    size?: PropertyInfo;
+};
+export declare const filterSafeGridDimensionProperties: (existingProps: {
+    width?: Dim;
+    height?: Dim;
+    size?: Dim;
+}) => {
+    width?: PropertyInfo;
+    height?: PropertyInfo;
+    size?: PropertyInfo;
+};
+export {};

package/dist-types/edit-mode/dnd/utils.test.d.ts

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

package/dist-types/edit-mode/duplicated-name-popover.d.ts

@@ -0,0 +1,7 @@
+import type { SbElement } from "@superblocksteam/library-shared/types";
+export declare const DuplicatedNamePopover: import("react").FunctionComponent<{
+    name: string;
+    children: React.ReactNode;
+    showWarning: boolean;
+    sourceId: SbElement;
+}>;

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

@@ -0,0 +1,47 @@
+import { ViteMessageKind } from "@superblocksteam/library-shared/types";
+import { AiManager } from "./features/ai-store.js";
+import ConnectionManager from "./features/connection-manager.js";
+import InteractionLayerManager from "./features/interaction-layer-manager.js";
+import OperationManager from "./features/operation-store.js";
+import PropertiesPanelManager from "./features/properties-panel-manager.js";
+import RuntimeEntitiesManager from "./features/runtime-entities-manager.js";
+import UIStore from "./features/ui-store.js";
+import type { RootStore } from "../lib/internal-details/lib/root-store.js";
+import type { ViteMessage } from "@superblocksteam/library-shared/types";
+export declare class EditStore {
+    ui: UIStore;
+    operationManager: OperationManager;
+    propertiesPanelManager: PropertiesPanelManager;
+    runtimeEntitiesManager: RuntimeEntitiesManager;
+    interactionLayerManager: InteractionLayerManager;
+    connectionManager: ConnectionManager;
+    ai: AiManager;
+    isInitialized: boolean;
+    recordingInitialized: boolean;
+    currentImportError: {
+        importPath: string;
+        error: string;
+        stack: string;
+    } | null;
+    private viteMessageListeners;
+    constructor(rootStore: RootStore);
+    setIsInitialized(isInitialized: boolean): void;
+    setupImportErrorListener(): void;
+    onViteMessage<T extends ViteMessageKind, Message extends Extract<ViteMessage, {
+        kind: T;
+    }>>(kind: T, callback: (message: Message) => void): () => void;
+    triggerViteMessage<T extends ViteMessageKind, Message extends Extract<ViteMessage, {
+        kind: T;
+    }>>(kind: T, message: Message): void;
+    startRecording(recording: {
+        userId: string;
+        appId: string;
+        sessionRecordingKey: string;
+    }): void;
+}
+export declare function initializeEditStore(): void;
+declare global {
+    interface Window {
+        __SUPERBLOCKS_EDITOR_HOOK__: EditStore;
+    }
+}

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

@@ -0,0 +1,18 @@
+import React from "react";
+import type { ChildFunction } from "./features/runtime-widgets-manager.js";
+import type { IdentifierInfo } from "../lib/internal-details/lib/features/name-manager.js";
+import type { SbInstance } from "@superblocksteam/library-shared/types";
+export declare const createAnchorNameStyle: (props: {
+    instanceId: SbInstance;
+}) => React.CSSProperties | undefined;
+declare const EditWrapper: React.FunctionComponent<{
+    type: string;
+    children: React.ReactNode[] | ChildFunction;
+    widgetProps: Record<string, unknown>;
+    isCustomComponent: boolean;
+    component: React.FC<any>;
+    identifier: IdentifierInfo;
+    isDroppable: boolean;
+    dropTargetRef?: React.RefObject<HTMLElement | null>;
+}>;
+export default EditWrapper;

package/dist-types/edit-mode/editor-hotkeys.d.ts

@@ -0,0 +1,3 @@
+export declare function EditorHotkeys({ children }: {
+    children: React.ReactNode;
+}): import("react").JSX.Element;

package/dist-types/edit-mode/extended-clickable-area.d.ts

@@ -0,0 +1,8 @@
+export declare const EXTENDED_CLICKABLE_AREA_DELTA = 6;
+export declare const EXTENDED_CLICKABLE_ANCHOR_CSS: {
+    top: string;
+    left: string;
+    right: string;
+    bottom: string;
+};
+export declare const EXTENDED_CLICKABLE_ANCHOR_CLIP_PATH = "polygon(\n              0% 0%, 0% 100%, 100% 100%, 100% 0%,\n              0% 0%, 6px 6px, calc(100% - 6px) 6px, \n              calc(100% - 6px) calc(100% - 6px), 6px calc(100% - 6px), 6px 6px\n            )";

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

@@ -0,0 +1,34 @@
+import { AiContextMode } from "@superblocksteam/library-shared/types";
+import type RuntimeEntitiesManager from "./runtime-entities-manager";
+import type { SbElement, SbInstance } from "@superblocksteam/library-shared/types";
+export declare class AiManager {
+    private readonly runtimeEntitiesManager;
+    private _isTaggingEnabled;
+    private _isEditing;
+    private _editingComponents;
+    private _contextMode;
+    private _targetedComponents;
+    private _targetedInstances;
+    constructor(runtimeEntitiesManager: RuntimeEntitiesManager);
+    getIsTaggingEnabled(): boolean;
+    setIsTaggingEnabled(isTaggingEnabled: boolean): void;
+    getAiContextMode(): AiContextMode;
+    shouldToggleComponentInAiContext(): boolean;
+    getTargetedComponents(): `SB-${string}`[];
+    isEditingComponent(id: SbElement): boolean;
+    isTargetingComponent(id: SbElement): boolean;
+    startEditing(): void;
+    setEditingComponents(components: SbElement[]): void;
+    finishEditing(): void;
+    setAiContextMode(mode: AiContextMode, components?: SbElement[]): void;
+    addTargetedInstance(instanceId: SbInstance): void;
+    toggleTargetedInstance(instanceId: SbInstance): void;
+    isTargetedInstance(instanceId: SbInstance): boolean;
+    /**
+     * Returns true if we are targeting a different instance of the same source id, since in some cases we want to keep
+     * the same source targeted, but just highlight another instance of it
+     */
+    isAlternateSourceIdTarget(sourceId: SbElement, instanceId: SbInstance): boolean;
+    private removeAllSharedInstances;
+    private removeAllInstancesForSource;
+}

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

@@ -0,0 +1,9 @@
+export type ConnectionStatus = "pre-init" | "disconnected" | "connecting" | "connected";
+declare class ConnectionManager {
+    connectionStatus: ConnectionStatus;
+    constructor();
+    initializeSocket(): void;
+    connect(): void;
+    disconnect(): void;
+}
+export default ConnectionManager;

package/dist-types/edit-mode/features/drag-and-drop-store.d.ts

@@ -0,0 +1,67 @@
+import { GridManager } from "../dnd/grid-store.js";
+import { StackManager } from "../dnd/stack-store.js";
+import type { RootStore } from "../../lib/internal-details/lib/root-store.js";
+import type { ClientRect } from "@dnd-kit/core";
+import type { SbElement, SbInstance } from "@superblocksteam/library-shared/types";
+type DNDFeatures = {
+    dragAndDrop?: boolean;
+    nudging?: boolean;
+};
+export declare class DragAndDropManager {
+    private root;
+    stack: StackManager;
+    grid: GridManager;
+    private _dropTargetInstanceId;
+    private _isDragging;
+    private _isDraggingNewComponent;
+    private _activeDragRect;
+    private _activeTargetRect;
+    private _draggingWidgetSize;
+    private _dragToCanvasComponentType;
+    private _validRootIds;
+    private _shouldResizePage;
+    private _invalidDropTarget;
+    private _perWidgetFeatures;
+    widgetPositions: Record<SbInstance, ClientRect>;
+    constructor(root: RootStore);
+    get isDragging(): boolean;
+    get isDraggingNewComponent(): boolean;
+    get draggingWidgetSize(): {
+        height: number;
+        width: number;
+    };
+    get dropTargetId(): `I-${string}` | null;
+    get activeDragRect(): ClientRect | null;
+    get activeTargetRect(): ClientRect | null;
+    get shouldResizePage(): boolean;
+    get dropTargetWidgetType(): string | undefined;
+    get isDropTargetGridLike(): boolean;
+    get isDropTargetStackLike(): boolean;
+    get draggedWidgetType(): string | null | undefined;
+    get dragToCanvasComponentType(): string | null;
+    get validRootIds(): `I-${string}`[] | null;
+    get invalidDropTarget(): boolean;
+    canDragWidget(instanceId: SbInstance): boolean;
+    canNudgeWidget(instanceId: SbInstance): boolean;
+    setWidgetFeatures(id: SbElement, features: Partial<DNDFeatures>): void;
+    setIsDragging(isDragging: boolean): void;
+    /**
+     * Indicates a drag of a new component into the canvas (e.g: from the sidebar)
+     * Used to handle the dragging preview, and the drop handling
+     */
+    startNewComponentDrag({ componentType }: {
+        componentType: string | null;
+    }): void;
+    cancelNewComponentDrag(): void;
+    setValidRootIds(ids: SbInstance[]): void;
+    setInvalidDropTarget(invalid: boolean): void;
+    setDropTargetId(id: SbInstance | null): void;
+    setActiveDragRect(collidingRect: ClientRect | null): void;
+    setActiveTargetRect(rect: ClientRect | null): void;
+    setWidgetPosition(id: SbInstance, rect: ClientRect | null): void;
+    updateChildPositions(id: SbInstance): void;
+    private getPageElement;
+    resizePageIfNeeded(): void;
+    private restorePageDimensions;
+}
+export {};