@babylonjs/inspector 9.2.0 → 9.2.2

package/lib/misc/assert.d.ts

@@ -1,5 +0,0 @@
-/**
- * Asserts that the given value is truthy.
- * @param value The value to check.
- */
-export declare function Assert(value: unknown): asserts value;

package/lib/misc/graphUtils.d.ts

@@ -1,44 +0,0 @@
-/**
- * Performs a topological sort on a graph.
- * @param graph The set of nodes that make up the graph.
- * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
- * @param onSortedNode A function that is called for each node in the sorted order.
- * @remarks
- * This function allocates. Do not use it in the hot path. Instead use an instance of GraphUtils.
- */
-export declare function SortGraph<NodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT>, onSortedNode: (node: NodeT) => void): void;
-/**
- * Traverses a graph.
- * @param graph The set of nodes that make up the graph.
- * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
- * @param onBeforeTraverse A function that is called before traversing each node.
- * @param onAfterTraverse A function that is called after traversing each node.
- * @remarks
- * This function allocates. Do not use it in the hot path. Instead use an instance of GraphUtils.
- */
-export declare function TraverseGraph<NodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT> | null | undefined, onBeforeTraverse?: (node: NodeT) => void, onAfterTraverse?: (node: NodeT) => void): void;
-/**
- * A utility class for performing graph operations.
- * @remarks
- * The class allocates new objects, but each operation (e.g. sort, traverse) is allocation free. This is useful when used in the hot path.
- */
-export declare class GraphUtils<DefaultNodeT = unknown> {
-    private readonly _traversalState;
-    private _isTraversing;
-    /**
-     * Performs a topological sort on a graph.
-     * @param graph The set of nodes that make up the graph.
-     * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
-     * @param onSortedNode A function that is called for each node in the sorted order.
-     */
-    sort<NodeT extends DefaultNodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT>, onSortedNode: (node: NodeT) => void): void;
-    /**
-     * Traverses a graph.
-     * @param graph The set of nodes that make up the graph.
-     * @param getAdjacentNodes A function that returns the adjacent nodes for a given node.
-     * @param onBeforeTraverse A function that is called before traversing each node.
-     * @param onAfterTraverse A function that is called after traversing each node.
-     */
-    traverse<NodeT extends DefaultNodeT>(graph: Iterable<NodeT>, getAdjacentNodes: (node: NodeT) => Iterable<NodeT> | null | undefined, onBeforeTraverse?: (node: NodeT) => void, onAfterTraverse?: (node: NodeT) => void): void;
-    private _traverseCore;
-}

package/lib/misc/observableCollection.d.ts

@@ -1,23 +0,0 @@
-import { type IDisposable, type IReadonlyObservable } from "@babylonjs/core/index.js";
-/**
- * A collection of items that can be observed for changes.
- */
-export declare class ObservableCollection<T> {
-    private readonly _items;
-    private readonly _keys;
-    private readonly _observable;
-    /**
-     * An observable that notifies observers when the collection changes.
-     */
-    get observable(): IReadonlyObservable<void>;
-    /**
-     * The items in the collection.
-     */
-    get items(): readonly T[];
-    /**
-     * Adds an item to the collection.
-     * @param item The item to add.
-     * @returns A disposable that removes the item from the collection when disposed.
-     */
-    add(item: T): IDisposable;
-}

package/lib/modularTool.d.ts

@@ -1,42 +0,0 @@
-import { type IDisposable } from "@babylonjs/core/index.js";
-import { type IExtensionFeed } from "./extensibility/extensionFeed";
-import { type WeaklyTypedServiceDefinition, ServiceContainer } from "./modularity/serviceContainer";
-import { type ShellServiceOptions } from "./services/shellService";
-import { type ThemeMode } from "./services/themeService";
-export type ModularToolOptions = {
-    /**
-     * The namespace for the tool, used for scoping persisted settings and other storage.
-     */
-    namespace: string;
-    /**
-     * The container element where the tool will be rendered.
-     */
-    containerElement: HTMLElement;
-    /**
-     * The service definitions to be registered with the tool.
-     */
-    serviceDefinitions: readonly WeaklyTypedServiceDefinition[];
-    /**
-     * The theme mode to use. If not specified, the default is "system", which uses the system/browser preference, and the last used mode is persisted.
-     */
-    themeMode?: ThemeMode;
-    /**
-     * Whether to show the theme selector in the toolbar. Default is true.
-     */
-    showThemeSelector?: boolean;
-    /**
-     * The extension feeds that provide optional extensions the user can install.
-     */
-    extensionFeeds?: readonly IExtensionFeed[];
-    /**
-     * An optional parent ServiceContainer. Dependencies not found in the tool's own container
-     * will be resolved from this parent.
-     */
-    parentContainer?: ServiceContainer;
-} & ShellServiceOptions;
-/**
- * Creates a modular tool with a base set of common tool services, including the toolbar/side pane basic UI layout.
- * @param options The options for the tool.
- * @returns A token that can be used to dispose of the tool.
- */
-export declare function MakeModularTool(options: ModularToolOptions): IDisposable;

package/lib/modularity/serviceContainer.d.ts

@@ -1,64 +0,0 @@
-import { type IDisposable } from "@babylonjs/core/index.js";
-import { type IService, type ServiceDefinition } from "./serviceDefinition";
-export type WeaklyTypedServiceDefinition = Omit<ServiceDefinition<IService<symbol>[] | [], IService<symbol>[] | []>, "factory"> & {
-    /**
-     * A factory function responsible for creating a service instance.
-     */
-    factory: (...args: any) => ReturnType<ServiceDefinition<IService<symbol>[] | [], IService<symbol>[] | []>["factory"]>;
-};
-/**
- * A service container manages the lifetimes of a set of services.
- * It takes care of instantiating the services in the correct order based on their dependencies,
- * passing dependencies through to services, and disposing of services when the container is disposed.
- */
-export declare class ServiceContainer implements IDisposable {
-    private readonly _friendlyName;
-    private readonly _parent?;
-    private _isDisposed;
-    private readonly _serviceDefinitions;
-    private readonly _serviceDependents;
-    private readonly _serviceInstances;
-    private readonly _children;
-    /**
-     * Creates a new ServiceContainer.
-     * @param _friendlyName A human-readable name for debugging.
-     * @param _parent An optional parent container. Dependencies not found locally will be resolved from the parent.
-     */
-    constructor(_friendlyName: string, _parent?: ServiceContainer | undefined);
-    /**
-     * Adds a set of service definitions in the service container.
-     * The services are sorted based on their dependencies.
-     * @param args The service definitions to register, and optionally an abort signal.
-     * @returns A disposable that will remove the service definition from the service container.
-     */
-    addServicesAsync(...args: WeaklyTypedServiceDefinition[] | [...serviceDefinitions: WeaklyTypedServiceDefinition[], abortSignal: AbortSignal]): Promise<IDisposable>;
-    /**
-     * Registers a service definition in the service container.
-     * @param serviceDefinition The service definition to register.
-     * @param abortSignal An optional abort signal.
-     * @returns A disposable that will remove the service definition from the service container.
-     */
-    addServiceAsync<Produces extends IService<symbol>[] = [], Consumes extends IService<symbol>[] = []>(serviceDefinition: ServiceDefinition<Produces, Consumes>, abortSignal?: AbortSignal): Promise<IDisposable>;
-    private _addServiceAsync;
-    /**
-     * Resolves a dependency by contract identity for a consuming service.
-     * Checks local services first, then walks up the parent chain.
-     * Registers the consumer as a dependent in whichever container owns the dependency.
-     * @param contract The contract identity to resolve.
-     * @param consumer The service definition that consumes this dependency.
-     * @returns The resolved service instance.
-     */
-    private _resolveDependency;
-    /**
-     * Removes a consumer from the dependent set for a given contract, checking locally first then the parent chain.
-     * @param contract The contract identity.
-     * @param consumer The service definition to remove as a dependent.
-     */
-    private _removeDependentFromChain;
-    private _removeService;
-    /**
-     * Disposes the service container and all contained services.
-     * Throws if this container is still a parent of any live child containers.
-     */
-    dispose(): void;
-}

package/lib/modularity/serviceDefinition.d.ts

@@ -1,64 +0,0 @@
-import { type IDisposable } from "@babylonjs/core/index.js";
-/**
- * A helper to create a service factory function from a class constructor.
- * @param constructor The class to create a factory function for.
- * @returns A factory function that creates an instance of the class.
- */
-export declare function ConstructorFactory<Class extends new (...args: any) => any>(constructor: Class): (...args: ConstructorParameters<Class>) => InstanceType<Class>;
-declare const Contract: unique symbol;
-/**
- * This interface must be implemented by all service contracts.
- */
-export interface IService<ContractIdentity extends symbol> {
-    /**
-     * @internal
-     */
-    readonly [Contract]?: ContractIdentity;
-}
-type ExtractContractIdentity<ServiceContract extends IService<symbol>> = ServiceContract extends IService<infer ContractIdentity> ? ContractIdentity : never;
-type ExtractContractIdentities<ServiceContracts extends IService<symbol>[]> = {
-    [Index in keyof ServiceContracts]: ExtractContractIdentity<ServiceContracts[Index]>;
-};
-type UnionToIntersection<Union> = (Union extends any ? (k: Union) => void : never) extends (k: infer Intersection) => void ? Intersection : never;
-type MaybePromise<T> = T | Promise<T>;
-/**
- * A factory function responsible for creating a service instance.
- * Consumed services are passed as arguments to the factory function.
- * The returned value must implement all produced services, and may IDisposable.
- * If not services are produced, the returned value may implement IDisposable, otherwise it may return void.
- */
-export type ServiceFactory<Produces extends IService<symbol>[], Consumes extends IService<symbol>[]> = (...dependencies: [...Consumes, abortSignal?: AbortSignal]) => MaybePromise<Produces extends [] ? Partial<IDisposable> | void : Partial<IDisposable> & UnionToIntersection<Produces[number]>>;
-/**
- * Defines a service, which is a logical unit that consumes other services (dependencies), and optionally produces services that can be consumed by other services (dependents).
- */
-export type ServiceDefinition<Produces extends IService<symbol>[] = [], Consumes extends IService<symbol>[] = []> = {
-    /**
-     * A human readable name for the service to help with debugging.
-     */
-    friendlyName: string;
-    /**
-     * A function that instantiates the service.
-     */
-    factory: ServiceFactory<Produces, Consumes>;
-} & (Produces extends [] ? {
-    /**
-     * An empty list or undefined, since the type specification has indicated no contracts are produced.
-     */
-    produces?: [];
-} : {
-    /**
-     * The list of contract identities that this service produces for consumption by other services.
-     */
-    produces: ExtractContractIdentities<Produces>;
-}) & (Consumes extends [] ? {
-    /**
-     * An empty list or undefined, since the type specification has indicated that no other services are consumed.
-     */
-    consumes?: [];
-} : {
-    /**
-     * The list of contract identities of other services that this service consumes.
-     */
-    consumes: ExtractContractIdentities<Consumes>;
-});
-export {};

package/lib/reflectorService-DdPEZLjO.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reflectorService-DdPEZLjO.js","sources":["../../../../../../../../dev/inspector-v2/src/components/tools/reflectorTools.tsx","../../../../../../../../dev/inspector-v2/src/services/panes/tools/reflectorService.tsx"],"sourcesContent":["import { ButtonLine } from \"shared-ui-components/fluent/hoc/buttonLine\";\r\nimport { useState, useCallback, useRef, type FunctionComponent } from \"react\";\r\nimport { type Scene } from \"core/scene\";\r\nimport { TextInputPropertyLine, NumberInputPropertyLine } from \"shared-ui-components/fluent/hoc/propertyLines/inputPropertyLine\";\r\nimport { Reflector } from \"core/Misc/reflector\";\r\nimport { PlugConnectedRegular } from \"@fluentui/react-icons\";\r\n\r\nexport const ReflectorTools: FunctionComponent<{ scene: Scene }> = ({ scene }) => {\r\n    const [hostname, setHostname] = useState(\"localhost\");\r\n    const [port, setPort] = useState(1234);\r\n    const reflectorRef = useRef<Reflector | null>(null);\r\n\r\n    const connectReflector = useCallback(() => {\r\n        if (reflectorRef.current) {\r\n            reflectorRef.current.close();\r\n        }\r\n\r\n        reflectorRef.current = new Reflector(scene, hostname, port);\r\n    }, [scene, hostname, port]);\r\n\r\n    return (\r\n        <>\r\n            <TextInputPropertyLine label=\"Hostname\" value={hostname} onChange={(value) => setHostname(value)} />\r\n            <NumberInputPropertyLine label=\"Port\" value={port} onChange={(value) => setPort(value)} forceInt />\r\n            <ButtonLine label=\"Connect\" icon={PlugConnectedRegular} onClick={connectReflector} />\r\n        </>\r\n    );\r\n};\r\n","import { type ServiceDefinition } from \"../../../modularity/serviceDefinition\";\r\nimport { ToolsServiceIdentity, type IToolsService } from \"../toolsService\";\r\nimport { type IDisposable } from \"core/scene\";\r\nimport { ReflectorTools } from \"../../../components/tools/reflectorTools\";\r\n\r\nexport const ReflectorServiceDefinition: ServiceDefinition<[], [IToolsService]> = {\r\n    friendlyName: \"Reflector Tools\",\r\n    consumes: [ToolsServiceIdentity],\r\n    factory: (toolsService) => {\r\n        const contentRegistrations: IDisposable[] = [];\r\n\r\n        // Reflector content\r\n        contentRegistrations.push(\r\n            toolsService.addSectionContent({\r\n                key: \"Reflector\",\r\n                section: \"Reflector\",\r\n                component: ({ context }) => <ReflectorTools scene={context} />,\r\n            })\r\n        );\r\n\r\n        return {\r\n            dispose: () => {\r\n                contentRegistrations.forEach((registration) => registration.dispose());\r\n            },\r\n        };\r\n    },\r\n};\r\n\r\nexport default {\r\n    serviceDefinitions: [ReflectorServiceDefinition],\r\n} as const;\r\n"],"names":["_jsxs","_Fragment","_jsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOO,MAAM,cAAc,GAAwC,CAAC,EAAE,KAAK,EAAE,KAAI;IAC7E,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC;IACrD,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC;AACtC,IAAA,MAAM,YAAY,GAAG,MAAM,CAAmB,IAAI,CAAC;AAEnD,IAAA,MAAM,gBAAgB,GAAG,WAAW,CAAC,MAAK;AACtC,QAAA,IAAI,YAAY,CAAC,OAAO,EAAE;AACtB,YAAA,YAAY,CAAC,OAAO,CAAC,KAAK,EAAE;QAChC;AAEA,QAAA,YAAY,CAAC,OAAO,GAAG,IAAI,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC;IAC/D,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;AAE3B,IAAA,QACIA,IAAA,CAAAC,QAAA,EAAA,EAAA,QAAA,EAAA,CACIC,GAAA,CAAC,qBAAqB,IAAC,KAAK,EAAC,UAAU,EAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,KAAK,KAAK,WAAW,CAAC,KAAK,CAAC,EAAA,CAAI,EACpGA,GAAA,CAAC,uBAAuB,EAAA,EAAC,KAAK,EAAC,MAAM,EAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,KAAK,KAAK,OAAO,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAA,IAAA,EAAA,CAAG,EACnGA,GAAA,CAAC,UAAU,EAAA,EAAC,KAAK,EAAC,SAAS,EAAC,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,gBAAgB,EAAA,CAAI,CAAA,EAAA,CACtF;AAEX,CAAC;;ACtBM,MAAM,0BAA0B,GAA2C;AAC9E,IAAA,YAAY,EAAE,iBAAiB;IAC/B,QAAQ,EAAE,CAAC,oBAAoB,CAAC;AAChC,IAAA,OAAO,EAAE,CAAC,YAAY,KAAI;QACtB,MAAM,oBAAoB,GAAkB,EAAE;;AAG9C,QAAA,oBAAoB,CAAC,IAAI,CACrB,YAAY,CAAC,iBAAiB,CAAC;AAC3B,YAAA,GAAG,EAAE,WAAW;AAChB,YAAA,OAAO,EAAE,WAAW;AACpB,YAAA,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,KAAKA,GAAA,CAAC,cAAc,EAAA,EAAC,KAAK,EAAE,OAAO,EAAA,CAAI;AACjE,SAAA,CAAC,CACL;QAED,OAAO;YACH,OAAO,EAAE,MAAK;AACV,gBAAA,oBAAoB,CAAC,OAAO,CAAC,CAAC,YAAY,KAAK,YAAY,CAAC,OAAO,EAAE,CAAC;YAC1E,CAAC;SACJ;IACL,CAAC;;AAGL,uBAAe;IACX,kBAAkB,EAAE,CAAC,0BAA0B,CAAC;CAC1C;;;;"}

package/lib/services/extensionsListService.d.ts

@@ -1,3 +0,0 @@
-import { type ServiceDefinition } from "../modularity/serviceDefinition";
-import { type IShellService } from "./shellService";
-export declare const ExtensionListServiceDefinition: ServiceDefinition<[], [IShellService]>;

package/lib/services/panes/settingsService.d.ts

@@ -1,25 +0,0 @@
-import { type IDisposable, type Scene } from "@babylonjs/core/index.js";
-import { type DynamicAccordionSection, type DynamicAccordionSectionContent } from "../../components/extensibleAccordion";
-import { type IService, type ServiceDefinition } from "../../modularity/serviceDefinition";
-import { type ISceneContext } from "../sceneContext";
-import { type IShellService } from "../shellService";
-/**
- * The unique identity symbol for the settings service.
- */
-export declare const SettingsServiceIdentity: unique symbol;
-/**
- * Allows new sections or content to be added to the Settings pane.
- */
-export interface ISettingsService extends IService<typeof SettingsServiceIdentity> {
-    /**
-     * Adds a new section to the settings pane.
-     * @param section A description of the section to add.
-     */
-    addSection(section: DynamicAccordionSection): IDisposable;
-    /**
-     * Adds content to one or more sections in the settings pane.
-     * @param content A description of the content to add.
-     */
-    addSectionContent(content: DynamicAccordionSectionContent<Scene>): IDisposable;
-}
-export declare const SettingsServiceDefinition: ServiceDefinition<[ISettingsService], [IShellService, ISceneContext]>;

package/lib/services/reactContextService.d.ts

@@ -1,18 +0,0 @@
-import { type Context } from "react";
-import { type IDisposable } from "@babylonjs/core/index.js";
-import { type IService } from "../modularity/serviceDefinition";
-/**
- * The unique identity symbol for the react context service.
- */
-export declare const ReactContextServiceIdentity: unique symbol;
-export type ReactContextHandle<T> = IDisposable & {
-    updateValue: (newValue: T) => void;
-};
-/**
- * ReactContextService allows global React contexts to be added/removed/updated.
- */
-export interface IReactContextService extends IService<typeof ReactContextServiceIdentity> {
-    addContext<T>(provider: Context<T>["Provider"], initialValue: T, options?: {
-        order?: number;
-    }): ReactContextHandle<T>;
-}

package/lib/services/settingsStore.d.ts

@@ -1,55 +0,0 @@
-import { type IReadonlyObservable } from "@babylonjs/core/index.js";
-import { type IService } from "../modularity/serviceDefinition";
-/**
- * The unique identity symbol for the settings store service.
- */
-export declare const SettingsStoreIdentity: unique symbol;
-/**
- * Describes a setting by its key and default value.
- */
-export type SettingDescriptor<T> = {
-    /**
-     * The unique key used to identify this setting in the store.
-     */
-    readonly key: string;
-    /**
-     * The default value to use when the setting has not been explicitly set.
-     */
-    readonly defaultValue: T;
-};
-/**
- * Provides a key-value store for persisting user settings.
- */
-export interface ISettingsStore extends IService<typeof SettingsStoreIdentity> {
-    /**
-     * An observable that notifies when a setting has changed, providing the key of the changed setting.
-     */
-    onChanged: IReadonlyObservable<string>;
-    /**
-     * Reads a setting from the store.
-     * @param descriptor The descriptor of the setting to read.
-     * @returns The current value of the setting, or the default value if it has not been set.
-     */
-    readSetting<T>(descriptor: SettingDescriptor<T>): T;
-    /**
-     * Writes a setting to the store.
-     * @param descriptor The descriptor of the setting to write.
-     * @param value The value to write.
-     */
-    writeSetting<T>(descriptor: SettingDescriptor<T>, value: T): void;
-}
-/**
- * Default implementation of {@link ISettingsStore} that persists settings using browser local storage.
- */
-export declare class SettingsStore implements ISettingsStore {
-    private readonly _namespace;
-    private readonly _onChanged;
-    /**
-     * Creates a new settings store.
-     * @param _namespace A namespace used to scope the settings keys to avoid collisions with other stores.
-     */
-    constructor(_namespace: string);
-    get onChanged(): IReadonlyObservable<Readonly<string>>;
-    readSetting<T>(descriptor: SettingDescriptor<T>): T;
-    writeSetting<T>(descriptor: SettingDescriptor<T>, value: T): void;
-}

package/lib/services/shellService.d.ts

@@ -1,256 +0,0 @@
-import { type ComponentType } from "react";
-import { type IDisposable, type Nullable } from "@babylonjs/core/index.js";
-import { type IService, type ServiceDefinition } from "../modularity/serviceDefinition";
-import { type SettingDescriptor } from "./settingsStore";
-/**
- * Setting descriptor for persisting side pane dock location overrides.
- */
-export declare const SidePaneDockOverridesSettingDescriptor: SettingDescriptor<Record<string, Readonly<{
-    horizontalLocation: HorizontalLocation;
-    verticalLocation: VerticalLocation;
-}> | undefined>>;
-/**
- * Setting descriptor for persisting the left side pane width adjustment.
- */
-export declare const LeftSidePaneWidthAdjustSettingDescriptor: SettingDescriptor<number>;
-/**
- * Setting descriptor for persisting the left side pane height adjustment.
- */
-export declare const LeftSidePaneHeightAdjustSettingDescriptor: SettingDescriptor<number>;
-/**
- * Setting descriptor for persisting the right side pane width adjustment.
- */
-export declare const RightSidePaneWidthAdjustSettingDescriptor: SettingDescriptor<number>;
-/**
- * Setting descriptor for persisting the right side pane height adjustment.
- */
-export declare const RightSidePaneHeightAdjustSettingDescriptor: SettingDescriptor<number>;
-/**
- * Represents a horizontal location in the shell layout.
- */
-export type HorizontalLocation = "left" | "right";
-/**
- * Represents a vertical location in the shell layout.
- */
-export type VerticalLocation = "top" | "bottom";
-type TeachingMomentInfo = boolean | {
-    readonly title: string;
-    readonly description: string;
-};
-/**
- * Describes an item that can be added to one of the shell's toolbars.
- */
-export type ToolbarItemDefinition = {
-    /**
-     * A unique key for the toolbar item.
-     */
-    key: string;
-    /**
-     * The component to render for the toolbar item.
-     */
-    component: ComponentType;
-    /**
-     * An optional order for the toolbar item, relative to other items.
-     * Defaults to 0.
-     */
-    order?: number;
-    /**
-     * The horizontal location of the toolbar item.
-     * Can be either "left" or "right".
-     * In "compact" toolbar mode, "left" and "right" mean the "compact" toolbars at the top/bottom of the left/right side panes.
-     * In "full" toolbar mode, "left" and "right" mean the left side and right side of the full width toolbars above/below the side panes.
-     */
-    horizontalLocation: HorizontalLocation;
-    /**
-     * The vertical location of the toolbar item.
-     * Can be either "top" or "bottom".
-     */
-    verticalLocation: VerticalLocation;
-    /**
-     * An optional display name for the toolbar item, used for teaching moments, tooltips, etc.
-     */
-    displayName?: string;
-    /**
-     * An optional teaching moment info. The default assumes the toolbar item was added by an extension and provides a generic title and description based on the display name or id, which is helpful for discoverability of new items.
-     * Set this to false to suppress the teaching moment, which may be desirable for built in items or items that are added in a non-dynamic way.
-     * Set it to an object with a title and description to provide a custom teaching moment, which may be desirable if the generic title and description are not sufficient.
-     * Teaching moments are more helpful for dynamically added items, possibly from extensions.
-     */
-    teachingMoment?: TeachingMomentInfo;
-};
-/**
- * Describes a side pane that can be added to the shell's left or right side.
- */
-export type SidePaneDefinition = {
-    /**
-     * A unique key for the side pane.
-     */
-    key: string;
-    /**
-     * An icon component to render for the pane tab.
-     */
-    icon: ComponentType;
-    /**
-     * The component to render for the side pane's content.
-     */
-    content: ComponentType;
-    /**
-     * An optional order for the side pane, relative to other panes.
-     * Defaults to 0.
-     */
-    order?: number;
-    /**
-     * The horizontal location of the side pane.
-     * Can be either "left" or "right".
-     */
-    horizontalLocation: HorizontalLocation;
-    /**
-     * The vertical location of the side pane.
-     * Can be either "top" or "bottom".
-     */
-    verticalLocation: VerticalLocation;
-    /**
-     * The title of the side pane, displayed as a standardized header at the top of the pane.
-     */
-    title: string;
-    /**
-     * An optional teaching moment info. The default assumes the side pane was added by an extension and provides a generic title and description based on the display name or id, which is helpful for discoverability of new items.
-     * Set this to false to suppress the teaching moment, which may be desirable for built in items or items that are added in a non-dynamic way.
-     * Set it to an object with a title and description to provide a custom teaching moment, which may be desirable if the generic title and description are not sufficient.
-     * Teaching moments are more helpful for dynamically added panes, possibly from extensions.
-     */
-    teachingMoment?: TeachingMomentInfo;
-    /**
-     * Keep the pane mounted even when it is not visible. This is useful if you don't want the
-     * user to lose the complex visual state when switching between tabs.
-     */
-    keepMounted?: boolean;
-};
-type RegisteredSidePane = {
-    readonly key: string;
-    select(): void;
-};
-type SidePaneContainer = {
-    readonly isDocked: boolean;
-    dock(): void;
-    undock(): void;
-    readonly isCollapsed: boolean;
-    collapse(): void;
-    expand(): void;
-};
-/**
- * Describes content that can be added to the shell's central area (between the side panes and toolbars - e.g. the main content).
- */
-export type CentralContentDefinition = {
-    /**
-     * A unique key for the central content.
-     */
-    key: string;
-    /**
-     * The component to render for the central content.
-     */
-    component: ComponentType;
-    /**
-     * An optional order for content, relative to other central content.
-     * Defaults to 0.
-     */
-    order?: number;
-};
-/**
- * The unique identity symbol for the root component service.
- */
-export declare const RootComponentServiceIdentity: unique symbol;
-/**
- * Exposes a top level component that should be rendered as the React root.
- */
-export interface IRootComponentService extends IService<typeof RootComponentServiceIdentity> {
-    /**
-     * The root component that should be rendered as the React root.
-     */
-    readonly rootComponent: ComponentType;
-}
-/**
- * The unique identity symbol for the shell service.
- */
-export declare const ShellServiceIdentity: unique symbol;
-/**
- * Provides a shell for the application, including toolbars, side panes, and central content.
- * This service allows adding toolbar items, side panes, and central content dynamically.
- */
-export interface IShellService extends IService<typeof ShellServiceIdentity> {
-    /**
-     * Adds a new item to one of the shell's toolbars.
-     * @param item Defines the item to add.
-     */
-    addToolbarItem(item: Readonly<ToolbarItemDefinition>): IDisposable;
-    /**
-     * Adds a new side pane to the shell.
-     * @param pane Defines the side pane to add.
-     */
-    addSidePane(pane: Readonly<SidePaneDefinition>): IDisposable;
-    /**
-     * Adds new central content to the shell.
-     * @param content Defines the content area to add.
-     */
-    addCentralContent(content: Readonly<CentralContentDefinition>): IDisposable;
-    /**
-     * The left side pane container.
-     */
-    readonly leftSidePaneContainer: Nullable<SidePaneContainer>;
-    /**
-     * The right side pane container.
-     */
-    readonly rightSidePaneContainer: Nullable<SidePaneContainer>;
-    /**
-     * The side panes currently present in the shell.
-     */
-    readonly sidePanes: readonly RegisteredSidePane[];
-}
-type ToolbarMode = "full" | "compact";
-/**
- * Options for configuring the shell service.
- */
-export type ShellServiceOptions = {
-    /**
-     * The default width of the left side pane.
-     */
-    leftPaneDefaultWidth?: number;
-    /**
-     * The minimum width of the left side pane.
-     */
-    leftPaneMinWidth?: number;
-    /**
-     * The default width of the right side pane.
-     */
-    rightPaneDefaultWidth?: number;
-    /**
-     * The minimum width of the right side pane.
-     */
-    rightPaneMinWidth?: number;
-    /**
-     * The mode of the toolbars.
-     * Can be either "full" (default) or "compact".
-     * In "full" mode, toolbars are displayed above and below the side panes.
-     * In "compact" mode, toolbars are displayed at the top and bottom of the left and right side panes.
-     */
-    toolbarMode?: ToolbarMode;
-    /**
-     * Whether the left side pane should start collapsed. Default is false.
-     */
-    leftPaneDefaultCollapsed?: boolean;
-    /**
-     * Whether the right side pane should start collapsed. Default is false.
-     */
-    rightPaneDefaultCollapsed?: boolean;
-    /**
-     * A function that can remap the default location of side panes.
-     * @param sidePane The side pane to remap.
-     * @returns The new location for the side pane.
-     */
-    sidePaneRemapper?: (sidePane: Readonly<SidePaneDefinition>) => Nullable<{
-        horizontalLocation: HorizontalLocation;
-        verticalLocation: VerticalLocation;
-    }>;
-};
-export declare function MakeShellServiceDefinition({ leftPaneDefaultWidth, leftPaneMinWidth, rightPaneDefaultWidth, rightPaneMinWidth, leftPaneDefaultCollapsed, rightPaneDefaultCollapsed, toolbarMode, sidePaneRemapper, }?: ShellServiceOptions): ServiceDefinition<[IShellService, IRootComponentService], []>;
-export {};

package/lib/services/shellSettingsService.d.ts

@@ -1,3 +0,0 @@
-import { type ServiceDefinition } from "../modularity/serviceDefinition";
-import { type ISettingsService } from "./panes/settingsService";
-export declare const ShellSettingsServiceDefinition: ServiceDefinition<[], [ISettingsService]>;

package/lib/services/themeSelectorService.d.ts

@@ -1,3 +0,0 @@
-import { type ServiceDefinition } from "../modularity/serviceDefinition";
-import { type IShellService } from "../services/shellService";
-export declare const ThemeSelectorServiceDefinition: ServiceDefinition<[], [IShellService]>;