@superblocksteam/library 2.0.28 → 2.0.29-next.1

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

@@ -0,0 +1,91 @@
+import type { Name } from "./names.js";
+import type { EventFlow } from "../../../user-facing/event-flow.js";
+import type { ValidateFn } from "../../../user-facing/properties-panel/validators.js";
+import type { Executable, SbElement, SbInstance, ValidationState, EntityOutputProp, Entity, ScopedState, ValueInputProp } from "@superblocksteam/library-shared/types";
+export type GetterOptions = {
+    useSuspense?: boolean;
+};
+export type SingleInputProp<T = EntityOutputProp, ARGS extends any[] = any[]> = ValueInputProp<T, ARGS> | EventFlow;
+export type NestedInputProp<T, ARGS extends any[] = any[]> = T extends object ? {
+    [K in keyof T]: SingleInputProp<T[K], ARGS> | NestedInputProp<T[K], ARGS>;
+} : never;
+export type InputProp<T = EntityOutputProp, ARGS extends any[] = any[]> = SingleInputProp<T, ARGS> | NestedInputProp<T, ARGS>;
+export type EntityFunction<ARGS extends any[] = any[], R = EntityOutputProp> = (this: Entity, state: ScopedState, ...ARGS: ARGS) => R;
+export type ScopeId = string;
+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, options?: GetterOptions): Entity;
+    getEntityMeta(name: Name, options?: GetterOptions): Entity;
+    getEntityName(id: string): Name;
+    setEntityName(id: string, name: Name, currentName?: Name): void;
+};
+export interface IEntityManager {
+    getFullState: Record<string, Entity>;
+    getValidationState: Record<string, ValidationState>;
+    getScopeName(scopeId: string): string;
+    getState(scopeId: string, options?: GetterOptions): ScopedState;
+    getPossibleScope(scopeId: string): InternalScope | undefined;
+    getEntity(scopeId: string, name: Name, options?: GetterOptions): Entity;
+    getEntityById(scopeId: string, id: SbInstance, options?: GetterOptions): 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;
+        onlyMetaProps?: boolean;
+    }): 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;
+        excludeState?: boolean;
+    }): void;
+    computeValue<T, ARGS extends any[] = any[]>(params: {
+        scopeId: ScopeId;
+        name: Name;
+        value: SingleInputProp<T>;
+        validator?: ValidateFn<T>;
+        args?: ARGS;
+    }): T;
+}

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-extraction.test.d.ts

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

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

@@ -0,0 +1,6 @@
+import type { BindingString } from "@superblocksteam/library-shared";
+import type { EntityDerivedProp } from "@superblocksteam/library-shared/types";
+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/binding-strings/transform-bindings.test.d.ts

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

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

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

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

@@ -0,0 +1,6 @@
+declare global {
+    const input: {
+        value: number;
+    };
+}
+export {};

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

@@ -0,0 +1,7 @@
+import type { ScopedState } from "@superblocksteam/library-shared/types";
+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,3 @@
+import type { InternalScope } from "./base-entity-manager.js";
+import type { ScopedState } from "@superblocksteam/library-shared/types";
+export declare function createScopeProxy(scopes: InternalScope[], useSuspense?: boolean): ScopedState;

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

@@ -0,0 +1,26 @@
+import type { DeepObserveChange, Entity } 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/deep-observe.test.d.ts

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

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

@@ -0,0 +1,96 @@
+import { type ValidationState, type SbElement, type SbInstance } from "@superblocksteam/library-shared/types";
+import { type Name } from "./names.js";
+import type { IEntityManager, SingleInputProp, InternalScope, ScopeId, InputProp, GetterOptions } from "./base-entity-manager.js";
+import type { ValidateFn } from "../../../user-facing/properties-panel/validators.js";
+import type { ComponentRegistry } from "../features/component-registry.js";
+import type { Executable, Entity, ScopedState } from "@superblocksteam/library-shared/types";
+export declare const GLOBAL_SCOPE_ID = "Global";
+export declare class EntityManager implements IEntityManager {
+    readonly componentRegistry: ComponentRegistry;
+    private state;
+    private atoms;
+    private validationCache;
+    private dirComputeEngine;
+    private evalComputeEngine;
+    constructor(componentRegistry: ComponentRegistry, options?: {
+        devtools?: boolean;
+    });
+    getEntity(scopeId: string, name: Name, options?: GetterOptions): Entity;
+    getEntityById(scopeId: string, id: SbInstance, options?: GetterOptions): Entity;
+    getState(scopeId: string, options?: GetterOptions): ScopedState;
+    getScopeName(scopeId: string): string;
+    setValidationState(entityId: string, property: string, state: ValidationState): void;
+    get getValidationState(): Record<string, ValidationState>;
+    get getFullState(): Record<string, Entity>;
+    private getAccessibleScopes;
+    getScope(scopeId: string): InternalScope;
+    getPossibleScope(scopeId: string): InternalScope | undefined;
+    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 addInternalProperty;
+    private addProperty;
+    deleteEntity(params: {
+        name: Name;
+        scopeId: string;
+    }): void;
+    deleteProperty(params: {
+        scopeId: string;
+        name: Name;
+        prop: string;
+    }): void;
+    private deleteObsoleteNestedProperties;
+    private getNestedPropertyPaths;
+    deleteEntityById(params: {
+        scopeId: string;
+        entityId: string;
+    }): void;
+    resetEntity(params: {
+        scopeId: string;
+        name: Name;
+        key?: string;
+        onlyMetaProps?: boolean;
+    }): 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;
+        excludeState?: boolean;
+        args?: ARGS;
+    }): void;
+    computeValue<T, ARGS extends any[] = any[]>(params: {
+        scopeId: ScopeId;
+        name: Name;
+        value: SingleInputProp<T>;
+        validator?: ValidateFn<T>;
+        args?: ARGS;
+    }): T;
+    private getOrCreateAtom;
+}

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

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

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,8 @@
+import { type ComputedArgs } from "@superblocksteam/library-shared";
+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, args?: ComputedArgs) => 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 "@superblocksteam/library-shared/types";
+export declare const prettyPrintFunction: (func: EntityDerivedProp, args: any[], fnName: string) => string;

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

@@ -0,0 +1,6 @@
+import type { Entity, ScopedState } from "@superblocksteam/library-shared/types";
+declare function sanitizeObject<T extends object>(obj: T): T;
+declare function sanitizeEntity<T extends Entity>(entity: T): T;
+declare function sanitizeScopedState(state: ScopedState): ScopedState;
+declare function sanitizedToJS<T>(value: T): T;
+export { sanitizeObject, sanitizeEntity, sanitizeScopedState, sanitizedToJS };

package/dist-types/lib/internal-details/lib/evaluator/sanitize-object.test.d.ts

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

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

@@ -0,0 +1,8 @@
+declare const SuspenseSymbol: unique symbol;
+type SuspenseResult = {
+    __isSuspenseResult: typeof SuspenseSymbol;
+};
+declare function toJsOrSuspense<T extends Record<string, unknown>>(obj: T, key?: string): T | SuspenseResult;
+declare function removeSuspense<T extends Record<string, unknown>>(keys: string[], result: T | SuspenseResult, prevSafeResult: T | undefined): T;
+export { SuspenseSymbol, toJsOrSuspense, removeSuspense };
+export type { SuspenseResult };

package/dist-types/lib/internal-details/lib/evaluator/suspense-helpers.test.d.ts

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

package/dist-types/lib/internal-details/lib/evaluator/to-executables-or-values.d.ts

@@ -0,0 +1,36 @@
+import { EventFlow } from "../../../user-facing/event-flow.js";
+import type { SingleInputProp, InputProp, EntityFunction } from "./base-entity-manager.js";
+import type { LazyFunction } from "./lazy-function.js";
+import type { DataTypeString } from "@superblocksteam/library-shared/props";
+import type { EntityDerivedProp, EntityOutputProp } from "@superblocksteam/library-shared/types";
+type ExecutableType = "normal" | "function" | "mustache-bindings" | "external-function" | "event" | "lazy-function";
+export type ExecutableOrValue = {
+    type: ExecutableType;
+} & ({
+    type: "normal";
+    value: EntityOutputProp;
+} | {
+    type: "function";
+    value: EntityDerivedProp;
+} | {
+    type: "mustache-bindings";
+    value: EntityDerivedProp | EntityOutputProp;
+} | {
+    type: "external-function";
+    value: EntityFunction;
+} | {
+    type: "lazy-function";
+    value: LazyFunction;
+} | {
+    type: "event";
+    value: EventFlow;
+});
+type PathSchema = {
+    path: string;
+};
+type EntitySchema = PathSchema & {
+    dataType: DataTypeString;
+};
+export declare const toExecutablesOrValues: <T>(props: InputProp<T>, propsSchema?: EntitySchema[]) => [string, ExecutableOrValue][];
+export declare const toExecutableOrValue: <T>(path: string, value: SingleInputProp<T>, isAnExternalFunction?: boolean) => ExecutableOrValue;
+export {};

package/dist-types/lib/internal-details/lib/evaluator/to-executables-or-values.test.d.ts

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

package/dist-types/lib/internal-details/lib/evaluator/use-shallow-mobx-observer.d.ts

@@ -0,0 +1 @@
+export declare const useShallowMobxObserver: <T extends Record<string, unknown>>(obj: T, useSuspense?: boolean) => T;

package/dist-types/lib/internal-details/lib/evaluator/use-shallow-mobx-observer.test.d.ts

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

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

@@ -0,0 +1,51 @@
+import { type DeleteMeLibraryApi } from "@superblocksteam/library-shared/types";
+import type { RootStore } from "../root-store.js";
+export type ApiResult<T = any> = {
+    data?: T;
+    error?: string;
+};
+type ApiDependency = {
+    apiName: string;
+    params: string[];
+    dependencies: string[];
+};
+declare class ApiManager {
+    readonly rootStore: RootStore;
+    agentUrls: string[];
+    private token;
+    private accessToken;
+    private apisByName;
+    private apiNameToDepCandidates;
+    private apiNameToApiReferences;
+    private runningApiControllers;
+    private waitForInitApiPromise;
+    constructor(rootStore: RootStore);
+    setTokens(token: string, accessToken: string): void;
+    isInitialized(): boolean;
+    private awaitInitApiIfNeeded;
+    loadApiManifest({ apis, apiDependencies, }: {
+        apis?: Record<string, {
+            api: DeleteMeLibraryApi;
+            scopeId: string;
+        }>;
+        apiDependencies?: ApiDependency[];
+    }): void;
+    setAllApis(apis: Record<string, {
+        api: DeleteMeLibraryApi;
+        scopeId: string;
+    }>): void;
+    setApisLoaded(): void;
+    setApiDepCandidates(apiName: string, deps: string[]): void;
+    setApiReferences(apiName: string, deps: string[]): void;
+    updateApi(api: DeleteMeLibraryApi, scopeId: string): void;
+    deleteApi(apiName: string, scopeId?: string): void;
+    renameApi({ api, oldName, scopeId, }: {
+        api: DeleteMeLibraryApi;
+        oldName: string;
+        scopeId: string;
+    }): void;
+    runApi(apiName: string, scopeId: string, traceHeaders?: Record<string, string>): Promise<ApiResult>;
+    private findError;
+    cancelApi(apiName: string, _scopeId: string): Promise<void>;
+}
+export default ApiManager;

package/dist-types/lib/internal-details/lib/features/api-utils.d.ts

@@ -0,0 +1,79 @@
+import { ViewMode } from "@superblocksteam/shared";
+import { ApiResponseType } from "@superblocksteam/shared";
+import type { ApiV2ExecutionRequest, ApiV2ExecutionResponse, ExecutionResponse, StreamEvent } from "../types.js";
+import type { DeleteMeLibraryApi } from "@superblocksteam/library-shared/types";
+import type { Agent } from "@superblocksteam/shared";
+export type ExecuteV2ApiParams = {
+    body: ApiV2ExecutionRequest;
+    api: DeleteMeLibraryApi;
+    environment: string;
+    eventType: string;
+    notifyOnSystemError: boolean;
+    responseType: ApiResponseType;
+    onMessage?: (message: any) => void;
+    processStreamEvents?: (event: StreamEvent) => void;
+    controlFlowOnlyFiles?: FileRequestParam[];
+    abortController?: AbortController;
+    baseUrl: string;
+    agents: Array<Agent>;
+    viewMode: ViewMode;
+    accessToken: string;
+    token: string;
+    traceHeaders?: Record<string, string>;
+};
+export declare function executeV2Api(params: ExecuteV2ApiParams): Promise<ExecutionResponse | undefined | void>;
+export declare const HttpMethod: {
+    readonly Get: "GET";
+    readonly Post: "POST";
+    readonly Put: "PUT";
+    readonly Patch: "PATCH";
+    readonly Delete: "DELETE";
+};
+type HttpMethodName = (typeof HttpMethod)[keyof typeof HttpMethod];
+type FileRequestParam = {
+    originalName: string;
+    buffer: string;
+    encoding: "base64";
+    mimetype: "text/plain";
+};
+export interface HttpCallOptions extends BaseCallOptions {
+    baseUrl?: string;
+    controlFlowOnlyFiles?: FileRequestParam[];
+    bodyIsFormData?: boolean;
+}
+interface BaseCallOptions {
+    method: HttpMethodName;
+    url: string;
+    body?: Record<string, any>;
+    query?: Record<string, string | string[]>;
+    params?: Record<string, unknown>;
+    timeout?: number;
+    abortController?: AbortController;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    priority?: RequestPriority;
+}
+export declare const stream: ({ url, headers, body, onMessage, onComplete, onError, defaultError, method, baseUrl, signal, init: overrideInit, }: {
+    url: string;
+    init?: RequestInit;
+    headers?: Record<string, string>;
+    body?: Record<string, any>;
+    onMessage: (message: any) => void;
+    onComplete: () => void;
+    onError: (error: string, statusCode?: number) => void;
+    defaultError?: string;
+    method?: HttpMethodName;
+    baseUrl?: string;
+    signal?: AbortSignal;
+}) => Promise<void>;
+export declare class HttpError extends Error {
+    code: number;
+    critical: boolean;
+    constructor(code: number, critical?: boolean, m?: string);
+}
+export declare const parseStreamResult: (streamResult: Array<StreamEvent>, options?: {
+    includeFinalOutput?: boolean;
+}) => undefined | ApiV2ExecutionResponse;
+export declare const isApiV2ExecutionResponse: (response: ExecutionResponse | undefined | void) => response is ApiV2ExecutionResponse;
+export declare const decodeBytestringsInV2ExecutionResponse: (response: ExecutionResponse) => void;
+export {};

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

@@ -0,0 +1,62 @@
+import type { ManagedPropsList, PropertiesDefinition } from "../../../user-facing/properties-panel/props-builder.js";
+import type { EditorTemplate } from "../../sb-wrapper.jsx";
+import type { RootStore } from "../root-store.js";
+import type { EntityDefinition } from "@superblocksteam/library-shared/props";
+import type { Catalog, ComponentRegistryShareState, CatalogWithInternalDetails, EditorConfig, EntityCallableFunction } from "@superblocksteam/library-shared/types";
+import type * as React from "react";
+export type Type = {
+    isSb: symbol;
+    sbType: string;
+    isDroppable?: boolean;
+    hasExtendedClickArea?: boolean;
+    propertiesDefinition?: PropertiesDefinition;
+    catalog?: Catalog;
+    description?: string;
+} & React.ComponentType<any>;
+/**
+ * TODO: The component registry could be split into two a thin layer always on, and move some stuff to the EditStore.
+ * Some of the actions (rename, delete) and some of the data (isDroppable, hasExtendedClickArea) are editor-only.
+ */
+export declare class ComponentRegistry implements ComponentRegistryShareState {
+    readonly rootStore: RootStore;
+    private _typeRegistry;
+    private _customComponentRegistry;
+    private _managedPropsRegistry;
+    private _internalPropsRegistry;
+    private _editorTemplatesRegistry;
+    private _editorConfigsRegistry;
+    constructor(rootStore: RootStore);
+    addType(type: string, component: Type): void;
+    addCustomComponent(type: string, component: Type): void;
+    deleteCustomComponent(type: string): void;
+    renameCustomComponent(oldName: string, newName: string): void;
+    addManagedProps(type: string, props: ManagedPropsList): void;
+    deleteManagedProps(type: string): void;
+    addEditorTemplate(type: string, template: EditorTemplate<any>): void;
+    getEditorTemplates(type: string): EditorTemplate<any>[] | undefined;
+    addEditorConfig(type: string, config: EditorConfig): void;
+    addInternalProps(type: string, props: Array<{
+        path: string;
+        factory: () => any;
+    }>): void;
+    getInternalProps(type: string): Array<{
+        path: string;
+        factory: () => any;
+    }>;
+    getEditorConfig(type: string): EditorConfig<any> | undefined;
+    get entityDefinitions(): Record<string, EntityDefinition>;
+    get libraryComponentCatalogs(): CatalogWithInternalDetails[];
+    get libraryComponentEditorConfigs(): {
+        [k: string]: EditorConfig<any>;
+    };
+    get customComponentList(): string[];
+    get managedPropsRegistry(): Map<string, ManagedPropsList>;
+    getManagedProps(type: string): ManagedPropsList;
+    getComponent(type: string): Type | undefined;
+    /**
+     * Get the property path with the record identifier if it exists. For example,
+     * `columns.columnName.label` becomes `columns.*.label`, for record properties.
+     */
+    getPropertyWithRecordIdentifier(type: string, path: string): string;
+    get componentsWithCallFunctions(): Record<string, EntityCallableFunction[]>;
+}

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

@@ -0,0 +1,8 @@
+export declare function useGetCurrentUserQuery(): {
+    isLoading: boolean;
+    data: {
+        user: {
+            name: string;
+        };
+    };
+};

package/dist-types/lib/internal-details/lib/features/name-manager.d.ts

@@ -0,0 +1,38 @@
+import type { IEntityManager } from "../evaluator/base-entity-manager.js";
+import type { Name } from "../evaluator/names.js";
+import type { SbElement, SbInstance } from "@superblocksteam/library-shared/types";
+export type IdentifierInfo = {
+    sourceId: SbElement;
+    name: Name;
+    instanceId: SbInstance;
+    scopeId: string;
+};
+export declare class NameManager {
+    readonly entityManager: IEntityManager;
+    private _mountedIdentifiers;
+    private _allPossibleIdentifiers;
+    private _scopeToNameToIdentifiers;
+    private _allNamesToIdentifiers;
+    private _prefixOrderByKey;
+    constructor(entityManager: IEntityManager);
+    get scopeToNameToIds(): Record<string, Record<string, Record<SbInstance, IdentifierInfo>>>;
+    getWidgetName(instanceId: SbInstance): undefined | Name;
+    hasEntityWithName(name: string): boolean;
+    hasDuplicateNames(scopeId: string, name: string): boolean;
+    private nextNameAndIdForCombination;
+    private trackIdentifier;
+    private untrackIdentifier;
+    registerIdentifier(identifier: IdentifierInfo): void;
+    unregisterIdentifier(instanceId: SbInstance): void;
+    getExistingIdentifier(instanceId: SbInstance): IdentifierInfo | undefined;
+    registerAndGetIdentifiers(params: {
+        sourceId: SbElement | undefined;
+        name: string | undefined;
+        scopeId: string;
+        rootId?: SbInstance;
+        existingInstanceId?: SbInstance;
+    }): IdentifierInfo;
+    private getSharedNameCount;
+    changeWidgetName(instanceId: SbInstance, newName?: string): IdentifierInfo | null;
+    resetRootOrders(rootId: SbInstance): void;
+}

package/dist-types/lib/internal-details/lib/features/type-defs-utils.d.ts

@@ -0,0 +1,3 @@
+import type { ManagedProp } from "../../../user-facing/properties-panel/props-builder";
+import type { EntityDefinition } from "@superblocksteam/library-shared/props";
+export declare const analyzePropertyType: (propData: ManagedProp, prop: any) => EntityDefinition["props"][string]["dataType"];