@split-window/angular 0.0.0-stage → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,813 @@
1
+ import * as i0 from "@angular/core";
2
+ import { ApplicationRef, ChangeDetectorRef, ComponentRef, EnvironmentInjector, EnvironmentProviders, InjectionToken, Injector, OnChanges, OnDestroy, OnInit, Renderer2, Signal, SimpleChanges, TemplateRef, Type, ViewRef } from "@angular/core";
3
+ import { BaseSplitWindowEngine, ContainerState, ContainerState as ContainerState$1, DEFAULT_SPLIT_WINDOW_CONFIG, DIRECT_DOM_WRITER, NoopSplitAnimationEngine, SPLIT_CONTAINER_LAYOUTS, SPLIT_DEFAULT_EASING, SPLIT_NOOP_ANIMATION_ENGINE, SplitAnimationContext as SplitAnimationContext$1, SplitAnimationEngine, SplitAnimationEngine as SplitAnimationEngine$1, SplitAnimationEngineRegistry as SplitAnimationEngineRegistry$1, SplitAnimationFn as SplitAnimationFn$1, SplitAnimationFrame, SplitAnimationFrame as SplitAnimationFrame$1, SplitAnimationOptions as SplitAnimationOptions$1, SplitAnimationPreset, SplitAnimationPreset as SplitAnimationPreset$1, SplitAnimationProperties, SplitAnimationSettings, SplitAnimationSettings as SplitAnimationSettings$1, SplitBodyContainerOptions as SplitBodyContainerOptions$1, SplitBodyContainersConfig as SplitBodyContainersConfig$1, SplitBodySide, SplitBodySide as SplitBodySide$1, SplitCapacityContext, SplitCloseAllResult, SplitCloseAllResult as SplitCloseAllResult$1, SplitCloseContext, SplitCloseGuard, SplitCloseGuard as SplitCloseGuard$1, SplitCloseTrigger, SplitContainerElements as SplitContainerElements$1, SplitContainerFullError, SplitContainerLayout, SplitContainerLayout as SplitContainerLayout$1, SplitContainerNotFoundError, SplitContainerOptions as SplitContainerOptions$1, SplitContainerRegistry as SplitContainerRegistry$1, SplitContainerStateChange, SplitContainerStateChange as SplitContainerStateChange$1, SplitContainerTransitionEvent, SplitContainerTransitionEvent as SplitContainerTransitionEvent$1, SplitContainerView, SplitDismissAllOptions, SplitDismissAllOptions as SplitDismissAllOptions$1, SplitDomWriter, SplitDomWriter as SplitDomWriter$1, SplitDuplicateContainerError, SplitExpandOptions as SplitExpandOptions$1, SplitFunctionAnimationEngine, SplitInvalidOptionError, SplitMoveGuard, SplitNoDefaultContainerError, SplitOverflowDecision, SplitOverflowHandler, SplitOverflowStrategy, SplitRect, SplitRect as SplitRect$1, SplitRejectDecision, SplitRejectHandler, SplitRejectStrategy, SplitReservedContainerKeyError, SplitStyleStash, SplitStyleStash as SplitStyleStash$1, SplitTabMovedEvent, SplitTabMovedEvent as SplitTabMovedEvent$1, SplitTabRejectedEvent, SplitTabRejectedEvent as SplitTabRejectedEvent$1, SplitTabView, SplitTransitionPlan, SplitWindowConfig, SplitWindowConfig as SplitWindowConfig$1, SplitWindowConfigInput, SplitWindowConfigInput as SplitWindowConfigInput$1, SplitWindowController as SplitWindowController$1, SplitWindowError, SplitWindowLabels, SplitWindowOptions as SplitWindowOptions$1, SplitWindowRef, SplitWindowRef as SplitWindowRef$1, TabState, toClassList } from "@split-window/core";
4
+ import { CdkDrag, CdkDragDrop, CdkDropList } from "@angular/cdk/drag-drop";
5
+ import { Observable } from "rxjs";
6
+ /** Elements of a container. */
7
+ type SplitContainerElements = SplitContainerElements$1<HTMLElement>;
8
+ /** What an animation engine receives. */
9
+ type SplitAnimationContext = SplitAnimationContext$1<HTMLElement>;
10
+ /** A function used as an engine. */
11
+ type SplitAnimationFn = SplitAnimationFn$1<HTMLElement>;
12
+ /**
13
+ * What `animation.engine` accepts: the name of a registered engine, `'none'` (noop), an
14
+ * instance, a class (created with DI) or a function. Without a value: the first registered
15
+ * engine, or noop when none is registered.
16
+ */
17
+ type SplitAnimationEngineInput = 'none' | (string & {}) | SplitAnimationEngine$1<HTMLElement> | Type<SplitAnimationEngine$1<HTMLElement>> | SplitAnimationFn;
18
+ /** Animation options. Without `engine`: the first registered engine, or noop when there is none. */
19
+ interface SplitAnimationOptions extends Omit<SplitAnimationOptions$1<HTMLElement>, 'engine'> {
20
+ engine?: SplitAnimationEngineInput;
21
+ }
22
+ /** What the `animation` option accepts. */
23
+ type SplitAnimationInput = boolean | SplitAnimationPreset$1 | SplitAnimationOptions | SplitAnimationEngine$1<HTMLElement> | Type<SplitAnimationEngine$1<HTMLElement>> | SplitAnimationFn;
24
+ /** One class, several separated by spaces, or a list. */
25
+ type SplitClassInput = string | readonly string[];
26
+ /** What a mode (or a container) can set besides the layout behavior. */
27
+ interface SplitModeSettings {
28
+ /** Edge the panel docks to (custom containers). Default: `'right'`. */
29
+ side?: SplitBodySide$1;
30
+ /** Panel size on the side axis: '360px', '30vw'. */
31
+ size?: string;
32
+ /** Element pushed by a body container in `push`. A string is a CSS selector. */
33
+ pushTarget?: HTMLElement | string;
34
+ animation?: SplitAnimationInput;
35
+ /** Classes of the host (the app element, or the fixed host of a body container). */
36
+ hostClass?: SplitClassInput;
37
+ /** Classes of the `split-container` element. */
38
+ panelClass?: SplitClassInput;
39
+ /** Classes of the backdrop. */
40
+ backdropClass?: SplitClassInput;
41
+ }
42
+ /** What a mode receives while it applies or removes its layout. */
43
+ interface SplitModeContext {
44
+ readonly container: ContainerState$1<HTMLElement>;
45
+ readonly kind: 'custom' | 'body';
46
+ readonly layout: SplitContainerLayout$1;
47
+ readonly side: SplitBodySide$1;
48
+ /** Resolved panel size, or `null` when the layout has none (inline, custom push without `size`). */
49
+ readonly size: string | null;
50
+ readonly elements: SplitContainerElements;
51
+ readonly document: Document;
52
+ /** Use it for every style or class change: it is undone after the container hides. */
53
+ readonly styles: SplitStyleStash$1;
54
+ /** Free space for the mode, kept while the container is open. */
55
+ readonly data: Record<string, unknown>;
56
+ }
57
+ /** Passed to a mode function. */
58
+ interface SplitModeResolveContext {
59
+ readonly key: string;
60
+ readonly kind: 'custom' | 'body';
61
+ /** Side of a body container. */
62
+ readonly side: SplitBodySide$1 | null;
63
+ readonly options: Readonly<Record<string, unknown>>;
64
+ }
65
+ /**
66
+ * Base class of the modes. A mode decides how the open container takes space (`open`,
67
+ * `close`), where a transition starts and ends (`frames`) and what it adds to the
68
+ * container (`settings`). Extend a built-in mode to change a part of it:
69
+ *
70
+ * ```ts
71
+ * class DrawerMode extends SplitOverlayMode {
72
+ * override settings() { return { panelClass: 'drawer', animation: { duration: 300 } }; }
73
+ * }
74
+ * ```
75
+ *
76
+ * Classes are created with dependency injection, so they can use `inject()`.
77
+ */
78
+ export declare abstract class SplitContainerMode {
79
+ abstract readonly layout: SplitContainerLayout$1;
80
+ /** Settings the mode adds over the global defaults. The container options win. */
81
+ settings(): SplitModeSettings;
82
+ /** Applies the open layout. Called before the show transition. */
83
+ open(ctx: SplitModeContext): void;
84
+ /** Called after the hide transition, right before `ctx.styles` is restored. */
85
+ close(ctx: SplitModeContext): void;
86
+ /** Called after the show transition. */
87
+ shown(ctx: SplitModeContext): void;
88
+ /** Called after the container is hidden. */
89
+ hidden(ctx: SplitModeContext): void;
90
+ /** Start and end frames, measured with the open layout applied. */
91
+ frames(ctx: SplitModeContext, phase: 'show' | 'hide'): {
92
+ from: SplitAnimationFrame$1;
93
+ to: SplitAnimationFrame$1;
94
+ };
95
+ /** The container fully open. */
96
+ protected openFrame(ctx: SplitModeContext): SplitAnimationFrame$1;
97
+ /** The container fully closed: moved out by its size toward the side, or transparent inline. */
98
+ protected closedFrame(ctx: SplitModeContext, open: SplitAnimationFrame$1): SplitAnimationFrame$1;
99
+ }
100
+ /** Moves a rectangle out by its own size toward a side. */
101
+ export declare function offsetRect(rect: SplitRect$1, side: SplitBodySide$1): SplitRect$1;
102
+ /** `width` for left/right, `height` for top/bottom. */
103
+ export declare function axisOf(side: SplitBodySide$1): 'width' | 'height';
104
+ /** The panel fills its host (custom containers only). */
105
+ export declare class SplitInlineMode extends SplitContainerMode {
106
+ readonly layout: "inline";
107
+ }
108
+ /**
109
+ * The panel floats over the content. Body containers: fixed at a window edge. Custom
110
+ * containers: the host becomes an anchor without size on the side axis and the panel is
111
+ * placed against its `side` edge, over the neighbors.
112
+ */
113
+ export declare class SplitOverlayMode extends SplitContainerMode {
114
+ readonly layout: "overlay";
115
+ }
116
+ /**
117
+ * The panel takes space and pushes the content. Body containers: adds the size to the
118
+ * padding of the push target (`document.body` by default) and sets
119
+ * `--split-body-offset-<side>` on `<html>`. Custom containers: the host grows from 0 to the
120
+ * size (or its natural size) on the side axis.
121
+ */
122
+ export declare class SplitPushMode extends SplitContainerMode {
123
+ readonly layout: "push";
124
+ open(ctx: SplitModeContext): void;
125
+ protected openFrame(ctx: SplitModeContext): SplitAnimationFrame$1;
126
+ protected closedFrame(ctx: SplitModeContext, open: SplitAnimationFrame$1): SplitAnimationFrame$1;
127
+ }
128
+ /** Hooks of a mode given as an object. */
129
+ interface SplitModeHooks {
130
+ /** After the layout of the base mode is applied. */
131
+ onOpen?(ctx: SplitModeContext): void;
132
+ /** Before the layout of the base mode is removed. */
133
+ onClose?(ctx: SplitModeContext): void;
134
+ onShown?(ctx: SplitModeContext): void;
135
+ onHidden?(ctx: SplitModeContext): void;
136
+ }
137
+ /**
138
+ * A mode given as an object. Without `extends`, it builds on the built-in mode of its
139
+ * `layout` (default: inline for custom containers, overlay for body containers).
140
+ */
141
+ interface SplitModeDefinition extends SplitModeSettings, SplitModeHooks {
142
+ /** Mode to build on: a name, a definition, a class, an instance or a function. */
143
+ extends?: SplitModeInput;
144
+ layout?: SplitContainerLayout$1;
145
+ }
146
+ /** A function that picks the mode of a container. */
147
+ type SplitModeFn = (ctx: SplitModeResolveContext) => SplitModeInput;
148
+ /**
149
+ * What the `mode` option accepts: a built-in layout or a registered name, an object, a
150
+ * class (created with DI), an instance, or a function.
151
+ */
152
+ type SplitModeInput = SplitContainerLayout$1 | (string & {}) | SplitModeDefinition | SplitContainerMode | Type<SplitContainerMode> | SplitModeFn;
153
+ /** Mode built from a `SplitModeDefinition` over a base mode. */
154
+ export declare class SplitDefinedMode extends SplitContainerMode {
155
+ /** Mode whose settings are inherited. */
156
+ readonly base: SplitContainerMode;
157
+ /** Mode whose layout behavior is used (the base, or the built-in of `definition.layout`). */
158
+ readonly delegate: SplitContainerMode;
159
+ readonly definition: SplitModeDefinition;
160
+ constructor(
161
+ /** Mode whose settings are inherited. */
162
+ base: SplitContainerMode,
163
+ /** Mode whose layout behavior is used (the base, or the built-in of `definition.layout`). */
164
+ delegate: SplitContainerMode, definition: SplitModeDefinition);
165
+ get layout(): SplitContainerLayout$1;
166
+ settings(): SplitModeSettings;
167
+ open(ctx: SplitModeContext): void;
168
+ close(ctx: SplitModeContext): void;
169
+ shown(ctx: SplitModeContext): void;
170
+ hidden(ctx: SplitModeContext): void;
171
+ frames(ctx: SplitModeContext, phase: 'show' | 'hide'): {
172
+ from: SplitAnimationFrame$1;
173
+ to: SplitAnimationFrame$1;
174
+ };
175
+ }
176
+ /**
177
+ * Injected in the component (or template context) opened as a tab: close it, rename it and
178
+ * follow its current container, which can change after creation.
179
+ */
180
+ export declare class SplitActiveWindow<T = unknown> {
181
+ readonly ref: SplitWindowRef$1<T>;
182
+ private readonly _containerKey;
183
+ private readonly _title;
184
+ private readonly _label;
185
+ private readonly _active;
186
+ /** Current container. A signal, because the tab can move after it was created. */
187
+ readonly containerKey: Signal<string | null>;
188
+ readonly title: Signal<string>;
189
+ /** Title with the number, as in the strip. */
190
+ readonly label: Signal<string>;
191
+ readonly isActive: Signal<boolean>;
192
+ /** @internal Created by the engine for each tab. */
193
+ constructor(ref: SplitWindowRef$1<T>);
194
+ close(result?: any, options?: {
195
+ force?: boolean;
196
+ }): Promise<boolean>;
197
+ dismiss(reason?: any, options?: {
198
+ force?: boolean;
199
+ }): Promise<boolean>;
200
+ setTitle(title: string): void;
201
+ setClosable(closable: boolean): void;
202
+ setCanClose(guard: SplitCloseGuard$1 | null): void;
203
+ /** @internal */
204
+ sync(): void;
205
+ }
206
+ /**
207
+ * Named animation engines, as an Angular service. Starts with the engines of
208
+ * `provideSplitWindows({ animationEngines })` and `provideSplitAnimationEngines()`, in
209
+ * order, and creates engine classes with dependency injection. Inject it to register more
210
+ * engines at any time:
211
+ *
212
+ * ```ts
213
+ * inject(SplitAnimationEngineRegistry).register('pop', PopAnimationEngine);
214
+ * ```
215
+ *
216
+ * Engines are resolved on each transition, so a registration counts from the next
217
+ * open/close on: a container without a chosen engine uses the first registered one, and a
218
+ * container that names an engine uses it once it is registered.
219
+ *
220
+ * Registered only by `provideSplitWindows()`. Replace it with a subclass through
221
+ * `provideSplitWindows({ animationEngineRegistry })`.
222
+ */
223
+ export declare class SplitAnimationEngineRegistry extends SplitAnimationEngineRegistry$1<HTMLElement> {
224
+ constructor();
225
+ static ɵfac: i0.ɵɵFactoryDeclaration<SplitAnimationEngineRegistry, never>;
226
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
227
+ }
228
+ /** Everything the engine needs to render a container in its mode. */
229
+ interface SplitResolvedMode {
230
+ readonly mode: SplitContainerMode;
231
+ readonly kind: 'custom' | 'body';
232
+ readonly layout: SplitContainerLayout$1;
233
+ readonly side: SplitBodySide$1;
234
+ readonly size: string | null;
235
+ readonly pushTarget: HTMLElement | string | null;
236
+ readonly hostClass: string[];
237
+ readonly panelClass: string[];
238
+ readonly backdropClass: string[];
239
+ /** Whether the container animates its transitions. */
240
+ readonly animated: boolean;
241
+ /**
242
+ * Chosen animation engine (a name, an instance, a class or a function), or `undefined`
243
+ * for the first registered one. Resolved by `SplitAnimationEngineRegistry` on each
244
+ * transition, so engines registered later count.
245
+ */
246
+ readonly engine: SplitAnimationEngineInput | undefined;
247
+ readonly animation: SplitAnimationSettings$1;
248
+ }
249
+ /**
250
+ * @internal Resolves modes and animations: built-in layouts, registered names, objects,
251
+ * classes (created with DI), instances and functions, merged with the global defaults.
252
+ * The animation engine is only chosen here; `SplitAnimationEngineRegistry` resolves it.
253
+ */
254
+ declare class SplitModeResolver {
255
+ private readonly injector;
256
+ private readonly config;
257
+ private readonly defaults;
258
+ private readonly named;
259
+ private readonly instances;
260
+ private readonly builtins;
261
+ /** Names that `mode` accepts. */
262
+ modeNames(): string[];
263
+ /**
264
+ * Early check of a container's mode, done on registration: unknown names and `inline`
265
+ * on the body. Functions are only checked when they run.
266
+ */
267
+ validate(mode: unknown, kind: 'custom' | 'body', option: string): void;
268
+ /** Resolves the mode, settings and animation of a container. */
269
+ resolve(container: ContainerState$1<HTMLElement>): SplitResolvedMode;
270
+ /** Resolves any mode input to an instance. */
271
+ resolveMode(input: SplitModeInput, ctx: SplitModeResolveContext, seen: Set<unknown>): SplitContainerMode;
272
+ /** Creates (once) a class with dependency injection. */
273
+ instantiate<T>(type: Type<T>): T;
274
+ private unknown;
275
+ private inlineOnBody;
276
+ static ɵfac: i0.ɵɵFactoryDeclaration<SplitModeResolver, never>;
277
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
278
+ }
279
+ /**
280
+ * Visual shell of a container: tab strip and content area. Created by the engine in
281
+ * `mountContainer`; tab panels are appended to the content area by the engine.
282
+ */
283
+ export declare class SplitContainerComponent implements OnInit {
284
+ private readonly controller;
285
+ private readonly engine;
286
+ private readonly destroyRef;
287
+ private readonly host;
288
+ readonly containerKey: import("@angular/core").InputSignal<string>;
289
+ readonly view: import("@angular/core").WritableSignal<SplitContainerView<HTMLElement> | null>;
290
+ readonly highlight: import("@angular/core").WritableSignal<boolean>;
291
+ readonly emptyLabel: string;
292
+ private readonly content;
293
+ private frozen;
294
+ readonly contentId: import("@angular/core").Signal<string>;
295
+ readonly contentData: import("@angular/core").Signal<SplitDropListData>;
296
+ readonly enterPredicate: (drag: CdkDrag<SplitWindowRef$1>) => boolean;
297
+ ngOnInit(): void;
298
+ /** Element that receives the tab panels. */
299
+ contentElement(): HTMLElement | null;
300
+ onDrop(event: CdkDragDrop<SplitDropListData, SplitDropListData, SplitWindowRef$1>): void;
301
+ onKeydown(event: KeyboardEvent): void;
302
+ /**
303
+ * Stops following the container state, keeping what is on screen (used while the
304
+ * container animates out, so its last tab does not disappear first).
305
+ */
306
+ freeze(): void;
307
+ /** Follows the container state again. */
308
+ unfreeze(): void;
309
+ private refresh;
310
+ static ɵfac: i0.ɵɵFactoryDeclaration<SplitContainerComponent, never>;
311
+ static ɵcmp: i0.ɵɵComponentDeclaration<SplitContainerComponent, "split-container", never, {
312
+ "containerKey": {
313
+ "alias": "containerKey";
314
+ "required": true;
315
+ "isSignal": true;
316
+ };
317
+ }, {}, never, never, true, never>;
318
+ }
319
+ /** A floating drop zone of a closed container. */
320
+ interface SplitFloatingZone {
321
+ key: string;
322
+ label: string;
323
+ rect: SplitRect$1;
324
+ }
325
+ /** Data attached to every CDK drop list of the library. */
326
+ interface SplitDropListData {
327
+ key: string;
328
+ kind: 'strip' | 'content' | 'float';
329
+ }
330
+ /** A rendered tab. */
331
+ interface AngularTabHandle {
332
+ ref: SplitWindowRef$1;
333
+ panel: HTMLElement;
334
+ /** Root view attached to the `ApplicationRef` for the whole life of the tab. */
335
+ view: ViewRef | null;
336
+ componentRef: ComponentRef<unknown> | null;
337
+ /**
338
+ * Change detector switched off while the tab is inactive. For components it is the
339
+ * component's own view: `ApplicationRef.detachView()` would also remove the nodes from the
340
+ * DOM, and the app tick ignores the attached flag of root views.
341
+ */
342
+ cd: ChangeDetectorRef | null;
343
+ active: SplitActiveWindow;
344
+ /** Container the panel is in. */
345
+ containerKey: string | null;
346
+ }
347
+ /** Mode of a container and the static classes and styles it put on the elements. */
348
+ interface SplitContainerDisplay {
349
+ resolved: SplitResolvedMode;
350
+ /** `container.options` the mode was resolved from: a new object means a reconfiguration. */
351
+ options: object;
352
+ /** Classes and styles of the mode, kept while the container exists. */
353
+ stash: SplitStyleStash$1;
354
+ }
355
+ /** A mounted container. */
356
+ interface SplitShellEntry {
357
+ componentRef: ComponentRef<SplitContainerComponent>;
358
+ /** The `split-container` element. */
359
+ shell: HTMLElement;
360
+ /** Element that holds the shell when not expanded (the app host or the body host). */
361
+ home: HTMLElement;
362
+ bodyHost: HTMLElement | null;
363
+ backdrop: HTMLElement | null;
364
+ expandCleanup: (() => void) | null;
365
+ display: SplitContainerDisplay;
366
+ /** Open layout of the mode, undone after the container hides. */
367
+ layout: SplitStyleStash$1;
368
+ /** Context of the applied open layout; `null` while closed. */
369
+ modeCtx: SplitModeContext | null;
370
+ }
371
+ /**
372
+ * Moves a node keeping its state where the browser supports `moveBefore()` (iframes do not
373
+ * reload, videos keep playing, focus is kept). Falls back to `insertBefore`, through the
374
+ * renderer when one is given (`Renderer2` has no `moveBefore`).
375
+ */
376
+ export declare function moveNode(parent: Element, node: Element, before?: Node | null, renderer?: Renderer2): void;
377
+ /**
378
+ * The Angular engine: renders the shells with `createComponent`, moves tabs without
379
+ * destroying them, applies full screen, the modes of the containers and, through
380
+ * `BaseSplitWindowEngine`, their animated transitions. It never decides: it asks the core.
381
+ * Every write to the DOM goes through `Renderer2` (also the styles of the modes, through a
382
+ * renderer-backed `SplitStyleStash`); only reads, focus, `moveBefore` and the synthetic
383
+ * events of `cancelDrag` use the DOM directly.
384
+ *
385
+ * Replace it with a subclass through dependency injection:
386
+ *
387
+ * ```ts
388
+ * @Injectable()
389
+ * class MyEngine extends AngularSplitEngine {
390
+ * protected override enter(container: ContainerState<HTMLElement>) {
391
+ * super.enter(container);
392
+ * // ...
393
+ * }
394
+ * }
395
+ * provideSplitWindows({ engine: MyEngine });
396
+ * ```
397
+ */
398
+ export declare class AngularSplitEngine extends BaseSplitWindowEngine<SplitContent, HTMLElement, SplitAngularTabOptions, HTMLElement> {
399
+ protected readonly appRef: ApplicationRef;
400
+ protected readonly environmentInjector: EnvironmentInjector;
401
+ protected readonly document: Document;
402
+ protected readonly resolver: SplitModeResolver;
403
+ protected readonly config: import("@split-window/core").SplitWindowConfig;
404
+ /** Named animation engines, resolved on each transition. */
405
+ protected readonly animationEngines: SplitAnimationEngineRegistry;
406
+ /** Renderer for every DOM write of the engine. */
407
+ protected readonly renderer: Renderer2;
408
+ /** Writer of the style stashes (modes included), backed by the renderer. */
409
+ protected readonly domWriter: import("@split-window/core").SplitDomWriter;
410
+ readonly isBrowser: boolean;
411
+ protected readonly shells: Map<string, SplitShellEntry>;
412
+ /** Modes of custom containers prepared on registration, before their first tab. */
413
+ protected readonly prepared: Map<string, SplitContainerDisplay>;
414
+ private layerRef;
415
+ private expandLayer;
416
+ private readonly lastKnownRects;
417
+ private readonly hostObserver;
418
+ /** Floating drop zones shown during a drag. */
419
+ readonly floatingZones: import("@angular/core").WritableSignal<SplitFloatingZone[]>;
420
+ disconnect(): void;
421
+ /**
422
+ * Resolves the mode of a custom container on registration and styles its host, so a
423
+ * `push`/`overlay` host is collapsed before the first tab.
424
+ */
425
+ prepareContainer(container: ContainerState$1<HTMLElement>): void;
426
+ /** Undoes `prepareContainer`. */
427
+ releaseContainer(container: ContainerState$1<HTMLElement>): void;
428
+ mountContainer(container: ContainerState$1<HTMLElement>): void;
429
+ unmountContainer(container: ContainerState$1<HTMLElement>): void;
430
+ /**
431
+ * Re-applies the options of a container after a change: backdrop, and the mode when
432
+ * `container.options` was replaced (reconfiguration).
433
+ */
434
+ applyContainerOptions(container: ContainerState$1<HTMLElement>): void;
435
+ /** Content element of a mounted container. */
436
+ contentElement(key: string): HTMLElement | null;
437
+ /** Shell element of a mounted container. */
438
+ shellElement(key: string): HTMLElement | null;
439
+ /** Resolved mode of a mounted (or prepared) container. */
440
+ resolvedMode(key: string): SplitResolvedMode | null;
441
+ protected destroyShell(key: string): void;
442
+ /** Creates an element with classes. */
443
+ protected createElement(tag: string, ...classes: string[]): HTMLElement;
444
+ /** Removes an element from its parent. */
445
+ protected detach(el: Element): void;
446
+ protected setHidden(el: HTMLElement, hidden: boolean): void;
447
+ protected toggleClass(el: Element, name: string, on: boolean): void;
448
+ private ensureLayer;
449
+ protected createDisplay(container: ContainerState$1<HTMLElement>): SplitContainerDisplay;
450
+ private staticElements;
451
+ /** Classes and styles of the mode that stay while the container exists. */
452
+ protected applyStatic(display: SplitContainerDisplay, els: {
453
+ host: HTMLElement;
454
+ shell: HTMLElement | null;
455
+ backdrop: HTMLElement | null;
456
+ }): void;
457
+ /** Creates or removes the backdrop of a body container. Returns whether it changed. */
458
+ private syncBackdrop;
459
+ protected elements(entry: SplitShellEntry): SplitContainerElements;
460
+ /** Applies the open layout of the mode. */
461
+ protected applyLayout(entry: SplitShellEntry, container: ContainerState$1<HTMLElement>): void;
462
+ /** Removes the open layout of the mode. */
463
+ protected removeLayout(entry: SplitShellEntry): void;
464
+ private setVisible;
465
+ protected isMounted(container: ContainerState$1<HTMLElement>): boolean;
466
+ protected isEntered(container: ContainerState$1<HTMLElement>): boolean;
467
+ protected enter(container: ContainerState$1<HTMLElement>): void;
468
+ protected leave(container: ContainerState$1<HTMLElement>): void;
469
+ protected beforeTransition(container: ContainerState$1<HTMLElement>): void;
470
+ /** Keeps the last tab and the strip on screen, without interaction, while hiding. */
471
+ protected setLeaving(container: ContainerState$1<HTMLElement>, leaving: boolean): void;
472
+ protected setAnimating(container: ContainerState$1<HTMLElement>, on: boolean): void;
473
+ protected afterShown(container: ContainerState$1<HTMLElement>): void;
474
+ protected prefersReducedMotion(): boolean;
475
+ protected transitionPlan(container: ContainerState$1<HTMLElement>, phase: 'show' | 'hide'): SplitTransitionPlan<HTMLElement> | null;
476
+ /**
477
+ * Engine of a transition, resolved now: engines registered after the container was set up
478
+ * count. `null` when the container does not animate. An unknown engine name is reported
479
+ * and the transition uses the noop engine.
480
+ */
481
+ protected animationEngineFor(resolved: SplitResolvedMode): SplitAnimationEngine$1<HTMLElement> | null;
482
+ protected destroyTab(handle: unknown): void;
483
+ protected containerOfTab(handle: unknown): string | null;
484
+ createTab(content: SplitContent, tab: TabState, ref: SplitWindowRef$1, options: SplitAngularTabOptions | undefined): AngularTabHandle;
485
+ attach(handle: unknown, container: ContainerState$1<HTMLElement>): void;
486
+ move(handle: unknown, to: ContainerState$1<HTMLElement>): void;
487
+ activate(handle: unknown): void;
488
+ deactivate(handle: unknown): void;
489
+ /**
490
+ * `SplitWindowRef.setInputData`: `setInput` for each input the component declares. An
491
+ * inactive tab gets the values when it is activated again.
492
+ */
493
+ setInputs(handle: unknown, inputs: Readonly<Record<string, unknown>>): void;
494
+ /**
495
+ * Entries of `data` that are inputs of `componentType`, skipping `undefined` values. Keys
496
+ * may be the property or the template name (alias); the yielded name is always the
497
+ * template name, the one `ComponentRef.setInput` expects.
498
+ */
499
+ protected resolveInputParams(data: Readonly<Record<string, unknown>>, componentType: Type<unknown>): Generator<[name: string, value: unknown]>;
500
+ setExpanded(container: ContainerState$1<HTMLElement>, expanded: boolean): void;
501
+ protected expand(container: ContainerState$1<HTMLElement>, entry: SplitShellEntry): () => void;
502
+ private getExpandLayer;
503
+ /**
504
+ * Called from `cdkDragStarted`, which the CDK emits before measuring connected lists:
505
+ * shows the floating zones and connects the source strip to the valid targets.
506
+ */
507
+ startDrag(ref: SplitWindowRef$1, sourceList: CdkDropList<SplitDropListData>): void;
508
+ /** Handles a drop on any list of the library and ends the drag. */
509
+ handleDrop(event: CdkDragDrop<SplitDropListData, SplitDropListData, SplitWindowRef$1>): void;
510
+ cancelDrag(): void;
511
+ private floatingZone;
512
+ private remember;
513
+ static ɵfac: i0.ɵɵFactoryDeclaration<AngularSplitEngine, never>;
514
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
515
+ }
516
+ /**
517
+ * The core controller as an Angular service: opening, rules, numbering, limits, closing,
518
+ * moving and the state of the containers (open, expanded). It connects itself to the
519
+ * engine. Replace it with a subclass through `provideSplitWindows({ controller })`.
520
+ *
521
+ * Registered only by `provideSplitWindows()`.
522
+ */
523
+ export declare class SplitWindowController extends SplitWindowController$1<SplitContent, HTMLElement, SplitAngularTabOptions> implements OnDestroy {
524
+ constructor();
525
+ /** The engine, typed as the Angular engine (or the subclass provided in its place). */
526
+ readonly engine: AngularSplitEngine;
527
+ ngOnDestroy(): void;
528
+ static ɵfac: i0.ɵɵFactoryDeclaration<SplitWindowController, never>;
529
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
530
+ }
531
+ /** What `open()` accepts. */
532
+ type SplitContent<T = unknown> = Type<T> | TemplateRef<any>;
533
+ /** Context of a template opened as a tab. */
534
+ interface SplitTemplateContext {
535
+ $implicit: SplitActiveWindow;
536
+ window: SplitActiveWindow;
537
+ }
538
+ /** Options of `SplitWindowManager.open()`. */
539
+ interface SplitWindowOptions extends SplitWindowOptions$1 {
540
+ /** Inputs set on the component with `setInput`. */
541
+ inputs?: Record<string, unknown>;
542
+ /**
543
+ * Parent injector of the tab. Without a value, the `EnvironmentInjector` of the manager
544
+ * (as in `NgbModal`): the manager does not know the injector of its caller.
545
+ */
546
+ injector?: Injector;
547
+ }
548
+ /** Options only the Angular engine understands. */
549
+ interface SplitAngularTabOptions {
550
+ inputs?: Record<string, unknown>;
551
+ injector?: Injector;
552
+ }
553
+ /** Display options of a container, resolved by the Angular engine. */
554
+ interface SplitContainerDisplayOptions {
555
+ /**
556
+ * Display mode: `'inline'` (default of custom containers), `'push'`, `'overlay'` (default
557
+ * of body containers), a mode registered in `provideSplitWindows({ modes })`, an object,
558
+ * a class extending `SplitContainerMode`, an instance or a function.
559
+ */
560
+ mode?: SplitModeInput;
561
+ /** Open/close animation. Default: off (or `containerDefaults.animation`). */
562
+ animation?: SplitAnimationInput;
563
+ /** Classes of the host (the app element, or the fixed host of a body container). */
564
+ hostClass?: SplitClassInput;
565
+ /** Classes of the `split-container` element. */
566
+ panelClass?: SplitClassInput;
567
+ /** Classes of the backdrop. */
568
+ backdropClass?: SplitClassInput;
569
+ }
570
+ type SplitContainerOptions = Omit<SplitContainerOptions$1<HTMLElement>, 'mode' | 'animation'> & SplitContainerDisplayOptions;
571
+ type SplitBodyContainerOptions = Omit<SplitBodyContainerOptions$1<HTMLElement>, 'mode' | 'animation'> & SplitContainerDisplayOptions;
572
+ interface SplitBodyContainersConfig extends Omit<SplitBodyContainersConfig$1<HTMLElement>, 'defaults' | SplitBodySide$1> {
573
+ /** Applies to every enabled side. */
574
+ defaults?: SplitBodyContainerOptions;
575
+ left?: boolean | SplitBodyContainerOptions;
576
+ right?: boolean | SplitBodyContainerOptions;
577
+ top?: boolean | SplitBodyContainerOptions;
578
+ bottom?: boolean | SplitBodyContainerOptions;
579
+ }
580
+ type SplitExpandOptions = SplitExpandOptions$1<HTMLElement>;
581
+ /** Global display defaults: a mode and settings, overridden by the mode and the container. */
582
+ interface SplitContainerDefaults extends SplitModeSettings {
583
+ mode?: SplitModeInput;
584
+ }
585
+ /** `containerDefaults` of `provideSplitWindows()`: for every container, then per kind. */
586
+ interface SplitContainerDefaultsConfig extends SplitContainerDefaults {
587
+ custom?: SplitContainerDefaults;
588
+ body?: SplitContainerDefaults;
589
+ }
590
+ /** Config of `provideSplitWindows()`. */
591
+ interface SplitWindowAngularConfig extends SplitWindowConfigInput$1 {
592
+ /** Named modes, used as `mode: '<name>'`. */
593
+ modes?: Record<string, SplitModeInput>;
594
+ /** Display defaults of the containers (mode, animation, classes...). */
595
+ containerDefaults?: SplitContainerDefaultsConfig;
596
+ /**
597
+ * Named animation engines, in order. An animated container without `animation.engine`
598
+ * uses the first one; the noop engine is used only when none is registered or
599
+ * `engine: 'none'` is chosen.
600
+ */
601
+ animationEngines?: Record<string, SplitAnimationEngineEntry>;
602
+ /** A subclass of `SplitAnimationEngineRegistry` to use instead of it. */
603
+ animationEngineRegistry?: Type<SplitAnimationEngineRegistry>;
604
+ /** A subclass of `AngularSplitEngine` to use instead of it. */
605
+ engine?: Type<AngularSplitEngine>;
606
+ /** A subclass of `SplitWindowController` to use instead of it. */
607
+ controller?: Type<SplitWindowController>;
608
+ }
609
+ /** Default values of SplitWindow, set through `provideSplitWindows(config)`. */
610
+ export declare const SPLIT_WINDOW_CONFIG: InjectionToken<SplitWindowConfig$1>;
611
+ /**
612
+ * Named modes (multi provider). `provideSplitWindows({ modes })` and `provideSplitModes()`
613
+ * add to it; a later record wins for the same name.
614
+ */
615
+ export declare const SPLIT_WINDOW_MODES: InjectionToken<readonly Record<string, SplitModeInput>[]>;
616
+ /** Display defaults of the containers, from `provideSplitWindows({ containerDefaults })`. */
617
+ export declare const SPLIT_CONTAINER_DEFAULTS: InjectionToken<SplitContainerDefaultsConfig>;
618
+ /** A registered animation engine: an instance or a class (created with DI). */
619
+ type SplitAnimationEngineEntry = SplitAnimationEngine$1<HTMLElement> | Type<SplitAnimationEngine$1<HTMLElement>>;
620
+ /**
621
+ * Named animation engines (multi provider), in registration order. Without a chosen
622
+ * engine, an animated container uses the first one; the noop engine is used only when none
623
+ * is registered or `engine: 'none'` is chosen. `provideSplitWindows({ animationEngines })`
624
+ * and `provideSplitAnimationEngines()` add to it.
625
+ */
626
+ export declare const SPLIT_ANIMATION_ENGINES: InjectionToken<readonly Record<string, SplitAnimationEngineEntry>[]>;
627
+ /**
628
+ * Registers SplitWindow. Every piece is a provider, so it can be replaced with a subclass:
629
+ * the engine (`engine`), the controller (`controller`), or any of them with your own
630
+ * provider for the same class. The services are created the first time something injects
631
+ * them, so an app can inject only the registry in a `provideAppInitializer`.
632
+ *
633
+ * ```ts
634
+ * providers: [
635
+ * provideSplitWindows({
636
+ * labels: { defaultTitle: 'New tab' },
637
+ * animationEngines: { css: SplitCssAnimationEngine },
638
+ * modes: { drawer: { extends: 'overlay', panelClass: 'drawer', animation: 'slide' } },
639
+ * containerDefaults: { animation: true },
640
+ * }),
641
+ * ]
642
+ * ```
643
+ */
644
+ export declare function provideSplitWindows(config?: SplitWindowAngularConfig): EnvironmentProviders;
645
+ /**
646
+ * Registers named modes, for libraries or feature areas. Must be in the same environment
647
+ * injector as `provideSplitWindows()`.
648
+ */
649
+ export declare function provideSplitModes(modes: Record<string, SplitModeInput>): EnvironmentProviders;
650
+ /**
651
+ * Registers named animation engines (instances or classes created with DI), after the ones
652
+ * of `provideSplitWindows()`. Must be in the same environment injector. To register at run
653
+ * time, inject `SplitAnimationEngineRegistry` and call `register()`.
654
+ *
655
+ * ```ts
656
+ * provideSplitAnimationEngines({
657
+ * css: SplitCssAnimationEngine,
658
+ * pop: new SplitKeyframesAnimationEngine({ show: [{ transform: 'scale(.9)' }, { transform: 'none' }] }),
659
+ * })
660
+ * ```
661
+ */
662
+ export declare function provideSplitAnimationEngines(engines: Record<string, SplitAnimationEngineEntry>): EnvironmentProviders;
663
+ /**
664
+ * Configuration of the containers: registered containers, body containers and the default
665
+ * container. It only stores: opening, closing and full screen are done by the controller
666
+ * (`SplitWindowManager`). Injectable on its own, for example in a `provideAppInitializer`.
667
+ *
668
+ * Registered only by `provideSplitWindows()`.
669
+ */
670
+ export declare class SplitContainerRegistry extends SplitContainerRegistry$1<HTMLElement> implements OnDestroy {
671
+ private readonly resolver;
672
+ /**
673
+ * Registers a container on a host. Besides the core options, accepts `mode`, `animation`
674
+ * and the `*Class` options. Unknown mode names throw here; animation engines may be
675
+ * registered later, so their names are checked on each transition.
676
+ */
677
+ registerContainer(key: string, host: HTMLElement, options?: SplitContainerOptions): void;
678
+ useBodyContainers(config?: SplitBodyContainersConfig): void;
679
+ ngOnDestroy(): void;
680
+ static ɵfac: i0.ɵɵFactoryDeclaration<SplitContainerRegistry, never>;
681
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
682
+ }
683
+ /**
684
+ * Public API to open tabs, in the format of `NgbOffcanvas` and `NgbModal`:
685
+ * `open(content, options)` returns a reference that controls the tab. Also controls the
686
+ * containers (full screen, state) through the controller.
687
+ *
688
+ * Registered only by `provideSplitWindows()`.
689
+ */
690
+ export declare class SplitWindowManager {
691
+ private readonly controller;
692
+ /** The registry singleton: configuration of the containers. */
693
+ readonly registry: SplitContainerRegistry;
694
+ /** Any reorder or container change of any tab. */
695
+ readonly tabMoved: Observable<SplitTabMovedEvent$1>;
696
+ /** A tab refused by the tab limit, with the resolution applied. */
697
+ readonly tabRejected: Observable<SplitTabRejectedEvent$1>;
698
+ /** Container opened, closed, expanded or restored. */
699
+ readonly containerStateChanged: Observable<SplitContainerStateChange$1>;
700
+ /** Show/hide transitions of the containers: start, progress, end or cancel. */
701
+ readonly containerTransitions: Observable<SplitContainerTransitionEvent$1>;
702
+ /**
703
+ * Opens a component or template as a tab. The container comes from `options.containerKey`
704
+ * or the default container.
705
+ */
706
+ open<T = any>(content: SplitContent<T>, options?: SplitWindowOptions): SplitWindowRef$1<T>;
707
+ /**
708
+ * Closes the tabs of a container (or of all containers) in sequence, waiting for each
709
+ * `canClose`. Tabs with `closable: false` are kept.
710
+ */
711
+ dismissAll(options?: SplitDismissAllOptions$1): Promise<SplitCloseAllResult$1>;
712
+ hasOpenWindows(containerKey?: string): boolean;
713
+ /** Open tabs of a container, in strip order. */
714
+ getTabs(containerKey: string): readonly SplitWindowRef$1[];
715
+ /**
716
+ * Expands a container, restoring the one that was expanded. Ignored when the container
717
+ * is closed or has `expand: false`.
718
+ */
719
+ expandContainer(key: string): void;
720
+ restoreContainer(key: string): void;
721
+ isContainerOpen(key: string): boolean;
722
+ isContainerExpanded(key: string): boolean;
723
+ /** Key of the expanded container, if any. */
724
+ getExpandedContainer(): string | null;
725
+ static ɵfac: i0.ɵɵFactoryDeclaration<SplitWindowManager, never>;
726
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
727
+ }
728
+ /**
729
+ * Registers the host element as a container. Registers in `ngOnInit` (so an `open()` in the
730
+ * `ngOnInit` of a later component already finds it) and unregisters on destroy, which
731
+ * dismisses its tabs with `'container-removed'`.
732
+ *
733
+ * ```html
734
+ * <div splitContainer="right" [splitContainerDefault]="true" [splitContainerOptions]="{ maxTabs: 5 }"></div>
735
+ * ```
736
+ */
737
+ export declare class SplitContainerDirective implements OnInit, OnChanges, OnDestroy {
738
+ private readonly registry;
739
+ private readonly element;
740
+ /** Container key. Changing it unregisters the old key and registers the new one. */
741
+ readonly splitContainer: import("@angular/core").InputSignal<string>;
742
+ /** Makes this container the default one. */
743
+ readonly splitContainerDefault: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
744
+ /** Options read on registration. */
745
+ readonly splitContainerOptions: import("@angular/core").InputSignal<SplitContainerOptions | undefined>;
746
+ private registeredKey;
747
+ ngOnInit(): void;
748
+ ngOnChanges(changes: SimpleChanges): void;
749
+ ngOnDestroy(): void;
750
+ private register;
751
+ private applyDefault;
752
+ private unregister;
753
+ static ɵfac: i0.ɵɵFactoryDeclaration<SplitContainerDirective, never>;
754
+ static ɵdir: i0.ɵɵDirectiveDeclaration<SplitContainerDirective, "[splitContainer]", ["splitContainer"], {
755
+ "splitContainer": {
756
+ "alias": "splitContainer";
757
+ "required": true;
758
+ "isSignal": true;
759
+ };
760
+ "splitContainerDefault": {
761
+ "alias": "splitContainerDefault";
762
+ "required": false;
763
+ "isSignal": true;
764
+ };
765
+ "splitContainerOptions": {
766
+ "alias": "splitContainerOptions";
767
+ "required": false;
768
+ "isSignal": true;
769
+ };
770
+ }, {}, never, never, true, never>;
771
+ }
772
+ /** Tab strip of a container: tabs, close buttons, full screen and close all. */
773
+ export declare class SplitTabStripComponent {
774
+ private readonly controller;
775
+ private readonly engine;
776
+ private readonly element;
777
+ private readonly injector;
778
+ readonly labels: import("@split-window/core").SplitWindowLabels;
779
+ readonly view: import("@angular/core").InputSignal<SplitContainerView<HTMLElement>>;
780
+ readonly dropList: import("@angular/core").Signal<CdkDropList<any>>;
781
+ readonly listId: import("@angular/core").Signal<string>;
782
+ readonly listData: import("@angular/core").Signal<SplitDropListData>;
783
+ readonly expanded: import("@angular/core").Signal<boolean>;
784
+ readonly hasClosableTabs: import("@angular/core").Signal<boolean>;
785
+ readonly enterPredicate: (drag: CdkDrag<SplitWindowRef$1>) => boolean;
786
+ activate(tab: SplitTabView): void;
787
+ closeTab(event: Event, tab: SplitTabView): void;
788
+ toggleExpand(): void;
789
+ closeAll(): void;
790
+ onDragStarted(ref: SplitWindowRef$1): void;
791
+ onDrop(event: CdkDragDrop<SplitDropListData, SplitDropListData, SplitWindowRef$1>): void;
792
+ /**
793
+ * WAI-ARIA tabs pattern with automatic activation: arrows, Home and End move between
794
+ * tabs; Delete closes; Ctrl+Shift+arrows reorder.
795
+ */
796
+ onTabKeydown(event: KeyboardEvent, tab: SplitTabView): void;
797
+ /** Focuses a tab after the strip re-renders (a reorder moves the element and drops focus). */
798
+ private focusTab;
799
+ static ɵfac: i0.ɵɵFactoryDeclaration<SplitTabStripComponent, never>;
800
+ static ɵcmp: i0.ɵɵComponentDeclaration<SplitTabStripComponent, "split-tab-strip", never, {
801
+ "view": {
802
+ "alias": "view";
803
+ "required": true;
804
+ "isSignal": true;
805
+ };
806
+ }, {}, never, never, true, never>;
807
+ }
808
+ /**
809
+ * A `SplitDomWriter` that writes through `Renderer2`, so the styles, classes and attributes
810
+ * of the modes (and of `SplitStyleStash`) go through Angular's renderer.
811
+ */
812
+ export declare function rendererDomWriter(renderer: Renderer2): SplitDomWriter$1;
813
+ export { type AngularTabHandle, type ContainerState, DEFAULT_SPLIT_WINDOW_CONFIG, DIRECT_DOM_WRITER, NoopSplitAnimationEngine, SPLIT_CONTAINER_LAYOUTS, SPLIT_DEFAULT_EASING, SPLIT_NOOP_ANIMATION_ENGINE, type SplitAnimationContext, SplitAnimationEngine, type SplitAnimationEngineEntry, type SplitAnimationEngineInput, type SplitAnimationFn, type SplitAnimationFrame, type SplitAnimationInput, type SplitAnimationOptions, type SplitAnimationPreset, type SplitAnimationProperties, type SplitAnimationSettings, type SplitBodyContainerOptions, type SplitBodyContainersConfig, type SplitBodySide, type SplitCapacityContext, type SplitClassInput, type SplitCloseAllResult, type SplitCloseContext, type SplitCloseGuard, type SplitCloseTrigger, type SplitContainerDefaults, type SplitContainerDefaultsConfig, type SplitContainerDisplay, type SplitContainerDisplayOptions, type SplitContainerElements, SplitContainerFullError, type SplitContainerLayout, SplitContainerNotFoundError, type SplitContainerOptions, type SplitContainerStateChange, type SplitContainerTransitionEvent, type SplitContent, type SplitDismissAllOptions, type SplitDomWriter, type SplitDropListData, SplitDuplicateContainerError, type SplitExpandOptions, SplitFunctionAnimationEngine, SplitInvalidOptionError, type SplitModeContext, type SplitModeDefinition, type SplitModeFn, type SplitModeHooks, type SplitModeInput, type SplitModeResolveContext, type SplitModeSettings, type SplitMoveGuard, SplitNoDefaultContainerError, type SplitOverflowDecision, type SplitOverflowHandler, type SplitOverflowStrategy, type SplitRect, type SplitRejectDecision, type SplitRejectHandler, type SplitRejectStrategy, SplitReservedContainerKeyError, type SplitResolvedMode, type SplitShellEntry, SplitStyleStash, type SplitTabMovedEvent, type SplitTabRejectedEvent, type SplitTemplateContext, type SplitWindowAngularConfig, type SplitWindowConfig, type SplitWindowConfigInput, SplitWindowError, type SplitWindowLabels, type SplitWindowOptions, SplitWindowRef, toClassList };