@theseam/ui-common 0.4.30 → 1.0.0-beta.0

package/services/index.d.ts

@@ -1,5 +1,129 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/services" />
-export * from './public-api';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { Router, UrlTree } from '@angular/router';
+import WebFont from 'webfontloader';
+
+interface TheSeamPreferencesAccessor {
+    /**
+     * Gets a preference.
+     */
+    get(name: string): Observable<string>;
+    /**
+     * Update a preference.
+     */
+    update(name: string, value: string): Observable<string>;
+    /**
+     * Delete a preference.
+     */
+    delete(name: string): Observable<boolean>;
+}
+
+interface TheSeamPreferencesBase {
+    version: number;
+}
+
+declare class TheSeamPreferencesManagerService {
+    private readonly _tablePrefsMap;
+    preferences(preferenceKey: string, accessor: TheSeamPreferencesAccessor, emptyPrefs: TheSeamPreferencesBase): Observable<TheSeamPreferencesBase>;
+    update(preferenceKey: string, value: TheSeamPreferencesBase): void;
+    delete(preferenceKey: string): void;
+    refresh(preferenceKey: string): void;
+    isPending(preferenceKey: string): boolean;
+    isLoaded(preferenceKey: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamPreferencesManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TheSeamPreferencesManagerService>;
+}
+
+type TheSeamPreferencesRecordStatus = 'pending' | 'loaded';
+interface TheSeamPreferencesRecordStatusChange {
+    previous: TheSeamPreferencesRecordStatus;
+    current: TheSeamPreferencesRecordStatus;
+}
+declare class TheSeamPreferencesMapRecord {
+    private readonly _key;
+    private readonly _accessor;
+    private readonly _emptyPrefs;
+    private readonly _refreshSubject;
+    private readonly _statusChangeSubject;
+    private _status;
+    readonly observable: Observable<TheSeamPreferencesBase>;
+    readonly statusChange: Observable<TheSeamPreferencesRecordStatusChange>;
+    constructor(_key: string, _accessor: TheSeamPreferencesAccessor, _emptyPrefs: TheSeamPreferencesBase);
+    private _createObservable;
+    update(value: TheSeamPreferencesBase): void;
+    delete(): void;
+    refresh(): void;
+    isSameAccessor(accessor: TheSeamPreferencesAccessor): boolean;
+    isSameEmptyPrefs(emptyPrefs: TheSeamPreferencesBase): boolean;
+    get status(): TheSeamPreferencesRecordStatus;
+    private _setStatus;
+    private _descerializePreferences;
+}
+
+declare class LoadedAssetRef<T extends HTMLLinkElement | HTMLScriptElement | HTMLStyleElement> {
+    readonly nativeElement: T;
+    readonly path?: string | undefined;
+    readonly content?: string | undefined;
+    constructor(nativeElement: T, path?: string | undefined, content?: string | undefined);
+    destroy(): void;
+}
+declare class AssetLoaderService {
+    loadStyleSheet(path: string): Observable<LoadedAssetRef<HTMLLinkElement>>;
+    loadStyle(content: string): Observable<LoadedAssetRef<HTMLStyleElement>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetLoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AssetLoaderService>;
+}
+
+declare class RouterHelpersService {
+    private _router;
+    constructor(_router: Router);
+    isActive(url: string | UrlTree, exact: boolean): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouterHelpersService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RouterHelpersService>;
+}
+
+type TheSeamFontEvents = {
+    type: 'loading';
+} | {
+    type: 'active';
+} | {
+    type: 'inactive';
+} | {
+    type: 'fontloading';
+    familyName: string;
+    fvd: string;
+} | {
+    type: 'fontactive';
+    familyName: string;
+    fvd: string;
+} | {
+    type: 'fontinactive';
+    familyName: string;
+    fvd: string;
+};
+/**
+ * Service to help loading fonts.
+ *
+ * Currently this is just a wrapper for the parts of webfontloader that we need.
+ * Eventually this should be generic enough that we can switch loaders without
+ * config differences being confusing.
+ */
+declare class TheSeamFontLoaderService {
+    /**
+     * Since this method is just a wrapper for webfontloader right now it accepts
+     * anything webfontloader's config accepts, so the event callbacks can still
+     * be used, but you should us the emitted objects instead. If we decide to
+     * support other font loaders then the event callbacks will most likely be
+     * removed.
+     *
+     * NOTE: If you need to use the events callbacks for some reason, this
+     * method's returned observable will still need to be subscribed to, because
+     * it doesn't start till subscribed to.
+     */
+    load(config: WebFont.Config): Observable<TheSeamFontEvents>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamFontLoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TheSeamFontLoaderService>;
+}
+
+export { AssetLoaderService, LoadedAssetRef, RouterHelpersService, TheSeamFontLoaderService, TheSeamPreferencesManagerService, TheSeamPreferencesMapRecord };
+export type { TheSeamFontEvents, TheSeamPreferencesAccessor, TheSeamPreferencesBase, TheSeamPreferencesRecordStatus, TheSeamPreferencesRecordStatusChange };

package/shared/index.d.ts

@@ -1,5 +1,229 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/shared" />
-export * from './public-api';
+import * as _fortawesome_fontawesome_common_types from '@fortawesome/fontawesome-common-types';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from '@angular/core';
+import { OnInit, EventEmitter, OnDestroy, AfterViewInit, AfterViewChecked, PipeTransform } from '@angular/core';
+import { ModalRef } from '@theseam/ui-common/modal';
+import { ResizeSensor } from 'css-element-queries';
+
+declare class TheSeamPasswordInputRevealComponent {
+    static ngAcceptInputType_passwordVisible: BooleanInput;
+    readonly faEye: _fortawesome_fontawesome_common_types.IconDefinition;
+    readonly faEyeSlash: _fortawesome_fontawesome_common_types.IconDefinition;
+    get inputRef(): HTMLInputElement | undefined | null;
+    set inputRef(value: HTMLInputElement | undefined | null);
+    private _passwordInput;
+    get passwordVisible(): boolean;
+    set passwordVisible(value: boolean);
+    _passwordVisible: boolean;
+    updateRevealState(): void;
+    revealPassword(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamPasswordInputRevealComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamPasswordInputRevealComponent, "seam-password-input-reveal", never, { "inputRef": { "alias": "inputRef"; "required": false; }; "passwordVisible": { "alias": "passwordVisible"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that will focus the element when initialized.
+ *
+ * If the element is inside a modal, it will wait until the modal is opened before focusing.
+ *
+ * If the element will be initialized multiple times or while a form is being filled out
+ * don't use this directive.
+ *
+ * Usage:
+ * ```html
+ * <input type="text" seamAutoFocus />
+ * ```
+ */
+declare class TheSeamAutoFocusDirective implements OnInit {
+    static ngAcceptInputType_seamAutoFocus: BooleanInput;
+    private readonly _elementRef;
+    private readonly _modal;
+    private readonly _modalRef;
+    private _focus;
+    modalRef: ModalRef<any> | undefined | null;
+    set seamAutoFocus(condition: boolean);
+    ngOnInit(): void;
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamAutoFocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamAutoFocusDirective, "[seamAutoFocus]", ["seamAutoFocus"], { "seamAutoFocus": { "alias": "seamAutoFocus"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TheSeamClickOutsideDirective {
+    private readonly _elementRef;
+    get seamClickOutsideActive(): boolean;
+    set seamClickOutsideActive(value: boolean);
+    private _active;
+    seamClickOutside: EventEmitter<MouseEvent>;
+    onDocumentClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamClickOutsideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamClickOutsideDirective, "[seamClickOutside]", ["seamClickOutside"], { "seamClickOutsideActive": { "alias": "seamClickOutsideActive"; "required": false; }; }, { "seamClickOutside": "seamClickOutside"; }, never, never, true, never>;
+}
+
+declare class TheSeamDisableControlDirective {
+    private readonly _ngControl;
+    set seamDisableControl(condition: boolean);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamDisableControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamDisableControlDirective, "[seamDisableControl]", ["seamDisableControl"], { "seamDisableControl": { "alias": "seamDisableControl"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface TheSeamElementResizedEvent {
+    element: HTMLElement;
+    size: {
+        width: number;
+        height: number;
+    };
+}
+declare class TheSeamElemResizedDirective implements OnDestroy, AfterViewInit {
+    private readonly _elementRef;
+    seamElemResized: EventEmitter<TheSeamElementResizedEvent>;
+    sensor?: ResizeSensor;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamElemResizedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamElemResizedDirective, "[seamElemResized]", ["seamElemResized"], {}, { "seamElemResized": "seamElemResized"; }, never, never, true, never>;
+}
+
+declare type _PointerEvent$1 = PointerEvent | PointerEvent;
+interface TheSeamHoverClassToggleRecord {
+    default: string;
+    hover: string;
+}
+/**
+ * Don't use this directive unless there is a reason not to use css `:hover`,
+ * because the accuracy of detecting the hover is not as good. If an element is
+ * moved while the mouse is idle the hover class will remain until the mouse
+ * enters and leaves again.
+ *
+ * I have tried multiple ways of detecting the mouse no longer hovering, but all
+ * have introduced a slight performance issue that just builds for each element
+ * containing this directive.
+ */
+declare class TheSeamHoverClassToggleDirective {
+    private readonly _elementRef;
+    private _hovered;
+    private _defaultClasses;
+    private _hoverClasses;
+    onMouseOver($event: MouseEvent): void;
+    onMouseOut($event: MouseEvent): void;
+    onPointerOver($event: _PointerEvent$1): void;
+    onPointerOut($event: _PointerEvent$1): void;
+    set seamHoverClassToggle(value: TheSeamHoverClassToggleRecord);
+    private _update;
+    private _setHovered;
+    private _addClass;
+    _removeClass(c: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamHoverClassToggleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamHoverClassToggleDirective, "[seamHoverClassToggle]", ["seamHoverClassToggle"], { "seamHoverClassToggle": { "alias": "seamHoverClassToggle"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare type _PointerEvent = PointerEvent | PointerEvent;
+/**
+ * Changes a css class on mouse pointer hover.
+ *
+ * NOTE: Only use this if css `:hover` can't be used, because css is more
+ * accurate and better performing.
+ *
+ * NOTE: Don't use this directive unless there is a reason not to use css
+ * `:hover`, because the accuracy of detecting the hover is not as good. If an
+ * element is moved while the mouse is idle the hover class will remain until
+ * the mouse enters and leaves again.
+ *
+ * NOTE: I have tried multiple ways of detecting the mouse no longer hovering,
+ * but all have introduced a slight performance issue that just builds for each
+ * element containing this directive.
+ */
+declare class TheSeamHoverClassDirective {
+    private readonly _elementRef;
+    private _hovered;
+    private _classes;
+    onMouseOver($event: MouseEvent): void;
+    onMouseOut($event: MouseEvent): void;
+    onPointerOver($event: _PointerEvent): void;
+    onPointerOut($event: _PointerEvent): void;
+    set seamHoverClass(classList: string);
+    private _update;
+    private _setHovered;
+    private _addClass;
+    _removeClass(c: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamHoverClassDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamHoverClassDirective, "[seamHoverClass]", ["seamHoverClass"], { "seamHoverClass": { "alias": "seamHoverClass"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TheSeamNgSelectExtraDirective implements OnInit, AfterViewChecked, OnDestroy {
+    private readonly _elementRef;
+    private readonly _ngZone;
+    private readonly _ngSelect;
+    private readonly _ngControl;
+    private readonly _ngUnsubscribe;
+    private _markedItem;
+    private _checkMarked;
+    private _keyPressWorkaroundSub;
+    private _resizedEvent;
+    private _resizeSensor?;
+    /**
+     * Set the tab index to `-1` to allow the root element of the ng-select
+     * component to receive `focus` event from javascript, but not get focused by
+     * keyboard navigation.
+     */
+    get _tabIndex(): -1 | undefined;
+    /**
+     * Listening for focus event on root of component to allow javascript
+     * `focus()` function to trigger the components focus.
+     */
+    onFocus($event: FocusEvent): void;
+    get _isInvalid(): boolean | null;
+    get _isEmptyStringValue(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewChecked(): void;
+    private _onScroll;
+    /**
+     * Temp fix for: https://github.com/ng-select/ng-select/issues/1122
+     */
+    /** Should ONLY be called by `_patch_ngSelect_open`. */
+    private _enableKeyPressWorkaround;
+    private _disableKeyPressWorkaround;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamNgSelectExtraDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamNgSelectExtraDirective, "ng-select", ["seamNgSelectExtra"], {}, {}, never, never, true, never>;
+}
+
+declare class TheSeamNgxQuillExtraDirective implements OnDestroy, AfterViewInit {
+    private readonly _elementRef;
+    private readonly _quillEditor;
+    private readonly _ngUnsubscribe;
+    private _tabIndex;
+    /**
+     * Set the tab index to `-1` to allow the root element of the
+     * component to receive `focus` event from javascript, but not get focused by
+     * keyboard navigation.
+     */
+    set tabIndex(value: number);
+    get tabIndex(): number;
+    get _attrTabIndex(): number;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    private _getParentElementForLabelFocusIssue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamNgxQuillExtraDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamNgxQuillExtraDirective, "quill-editor", ["seamNgxQuillExtra"], { "tabIndex": { "alias": "tabIndex"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TheSeamMaskCharsPipe implements PipeTransform {
+    transform(value: string, replacementChar?: string, ignoreCount?: number, ignoreFrom?: 'left' | 'right'): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamMaskCharsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TheSeamMaskCharsPipe, "maskChars", true>;
+}
+
+declare class TheSeamTruncatePipe implements PipeTransform {
+    transform(value: string, length?: number, appendEllipsis?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTruncatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TheSeamTruncatePipe, "truncate", true>;
+}
+
+declare class TheSeamSharedModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamSharedModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamSharedModule, never, [typeof TheSeamAutoFocusDirective, typeof TheSeamElemResizedDirective, typeof TheSeamHoverClassToggleDirective, typeof TheSeamNgSelectExtraDirective, typeof TheSeamHoverClassDirective, typeof TheSeamClickOutsideDirective, typeof TheSeamDisableControlDirective, typeof TheSeamNgxQuillExtraDirective, typeof TheSeamMaskCharsPipe, typeof TheSeamTruncatePipe, typeof TheSeamPasswordInputRevealComponent], [typeof TheSeamAutoFocusDirective, typeof TheSeamElemResizedDirective, typeof TheSeamPasswordInputRevealComponent, typeof TheSeamNgSelectExtraDirective, typeof TheSeamHoverClassDirective, typeof TheSeamHoverClassToggleDirective, typeof TheSeamClickOutsideDirective, typeof TheSeamDisableControlDirective, typeof TheSeamMaskCharsPipe, typeof TheSeamTruncatePipe, typeof TheSeamNgxQuillExtraDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamSharedModule>;
+}
+
+export { TheSeamAutoFocusDirective, TheSeamClickOutsideDirective, TheSeamDisableControlDirective, TheSeamElemResizedDirective, TheSeamHoverClassDirective, TheSeamHoverClassToggleDirective, TheSeamMaskCharsPipe, TheSeamNgSelectExtraDirective, TheSeamNgxQuillExtraDirective, TheSeamPasswordInputRevealComponent, TheSeamSharedModule, TheSeamTruncatePipe };
+export type { TheSeamElementResizedEvent, TheSeamHoverClassToggleRecord };

package/storage/index.d.ts

@@ -1,5 +1,35 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/storage" />
-export * from './public-api';
+import { Observable, BehaviorSubject } from 'rxjs';
+import * as i0 from '@angular/core';
+
+interface ILocalStorageService {
+    select(key: string, defaultValue: string | null): Observable<string | null>;
+    get(key: string, defaultValue: string | null): string | null;
+    set(key: string, value: string): void;
+    remove(key: string): void;
+}
+declare class LocalStorageService implements ILocalStorageService {
+    protected readonly subjects: {
+        [key: string]: BehaviorSubject<string | null>;
+    };
+    /** This is only here for testing/debugging. */
+    private readonly _localStorage;
+    constructor();
+    /**
+     * Observe a localStorage item.
+     *
+     * NOTE: Only emits changes if the item is changed with the set method of this
+     * class instance.
+     */
+    select(key: string, defaultValue?: string | null): Observable<string | null>;
+    /** Get a localStorage item. */
+    get(key: string, defaultValue?: string | null): string | null;
+    /** Set a localStorage item. */
+    set(key: string, value: string): void;
+    /** Remove a localStorage item. */
+    remove(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageService>;
+}
+
+export { LocalStorageService };
+export type { ILocalStorageService };

package/story-helpers/index.d.ts

@@ -1,5 +1,184 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/story-helpers" />
-export * from './public-api';
+import { HandlerFunction } from 'storybook/actions';
+import * as i0 from '@angular/core';
+import { ModuleWithProviders, OnDestroy, Injector, InjectionToken, ComponentRef } from '@angular/core';
+import { ReplaySubject, Observable } from 'rxjs';
+import { ModalConfig } from '@theseam/ui-common/modal';
+import { ComponentType } from '@theseam/ui-common/models';
+import * as i3 from '@angular/common';
+import * as i4 from '@angular/router';
+import * as i5 from '@theseam/ui-common/scrollbar';
+import { GlobalConfig, ActiveToast, ToastContainerDirective, IndividualConfig } from 'ngx-toastr';
+import { TheSeamPreferencesAccessor } from '@theseam/ui-common/services';
+
+declare type ArgType = any;
+declare const themeArgType: ArgType;
+declare const themeWithOutlineArgType: ArgType;
+declare const sizeArgType: ArgType;
+declare const buttonTypeArgType: ArgType;
+
+interface ArgsTplParts {
+    actions: {
+        [prop: string]: HandlerFunction;
+    };
+    tplfragment: string;
+}
+interface ArgsTplOptions {
+    /**
+     * Properties to always bind to the template.
+     */
+    alwaysBind?: string[];
+    /**
+     * Properties to exclude from bidning to the template.
+     */
+    exclude?: string[];
+}
+/**
+ * This is an attempt at simplifying the use of auto-generated args in stories
+ * defined with `template`, since Angular doesn't have a way to simply use a
+ * spread operator syntax.
+ *
+ * @experimental
+ */
+declare function argsToTpl(options?: ArgsTplOptions): string;
+
+declare class StoryEmptyComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StoryEmptyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StoryEmptyComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class StoryInitialRouteModule {
+    static forRoot(url: string): ModuleWithProviders<StoryInitialRouteModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StoryInitialRouteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<StoryInitialRouteModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<StoryInitialRouteModule>;
+}
+
+/**
+ * Until I find a way to avoid '@storybook/addon-knobs' from interfering with
+ * NgZone I can't import it in the knob when built by ng-packagr.
+ */
+declare function routeButton(buttonKnob: any, url: string): any;
+
+declare function routesArgType(routes: string[]): {
+    options: string[];
+    control: {
+        type: string;
+        onChange: (e: any, a: any) => any;
+    };
+};
+
+declare class StoryEmptyWithRouteComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StoryEmptyWithRouteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StoryEmptyWithRouteComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class StoryModalContainerComponent<T, D = any> implements OnDestroy {
+    private _injector;
+    private readonly _ngUnsubscribe;
+    set component(c: ComponentType<T>);
+    set data(d: D);
+    modalConfig?: ModalConfig<D>;
+    _component: ReplaySubject<ComponentType<T>>;
+    _data: ReplaySubject<D>;
+    _outletData$: Observable<{
+        component: ComponentType<T>;
+        injector: Injector;
+    } | null>;
+    constructor(_injector: Injector);
+    ngOnDestroy(): void;
+    private _createInjector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StoryModalContainerComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StoryModalContainerComponent<any, any>, "story-modal-container-component", never, { "component": { "alias": "component"; "required": false; }; "data": { "alias": "data"; "required": false; }; "modalConfig": { "alias": "modalConfig"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class StoryHelperComponentsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StoryHelperComponentsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<StoryHelperComponentsModule, [typeof StoryEmptyWithRouteComponent, typeof StoryModalContainerComponent], [typeof i3.CommonModule, typeof i4.RouterModule, typeof i5.TheSeamOverlayScrollbarDirective], [typeof StoryEmptyWithRouteComponent, typeof StoryModalContainerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<StoryHelperComponentsModule>;
+}
+
+declare const STORY_INITIAL_ROUTE_URL: InjectionToken<any>;
+declare class StoryInitialRouteService {
+    private _injector;
+    constructor(_injector: Injector);
+    setInitialRoute(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StoryInitialRouteService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StoryInitialRouteService>;
+}
+
+declare function storyInitialRouteFactory(_storyInitialRouteService: StoryInitialRouteService): () => void;
+
+declare class StoryToastrService {
+    toastrConfig?: GlobalConfig;
+    currentlyActive: number;
+    toasts: ActiveToast<any>[];
+    overlayContainer?: ToastContainerDirective;
+    previousToastMessage: string | undefined;
+    /** show toast */
+    show(message?: string, title?: string, override?: Partial<IndividualConfig>, type?: string): void;
+    /** show successful toast */
+    success(message?: string, title?: string, override?: Partial<IndividualConfig>): void;
+    /** show error toast */
+    error(message?: string, title?: string, override?: Partial<IndividualConfig>): void;
+    /** show info toast */
+    info(message?: string, title?: string, override?: Partial<IndividualConfig>): void;
+    /** show warning toast */
+    warning(message?: string, title?: string, override?: Partial<IndividualConfig>): void;
+    /**
+     * Remove all or a single toast by id
+     */
+    clear(toastId?: number): void;
+    /**
+     * Remove and destroy a single toast by id
+     */
+    remove(toastId: number): void;
+    /**
+     * Determines if toast message is already shown
+     */
+    findDuplicate(message: string, resetOnDuplicate: boolean, countDuplicates: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StoryToastrService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StoryToastrService>;
+}
+
+/**
+ * Can be used to trigger an event on a target element when the story component has been bootstrapped.
+ *
+ * Example:
+ * ```
+ * export const TouchExample1 = () => ({
+ *   moduleMetadata: {
+ *     providers: [ onStoryBootstrappedTrigger('input', 'blur') ]
+ *   },
+ *   props: { control: new FormControl('') },
+ *   template: `
+ *     <input type="text" [formControl]="control">
+ *     Touched: {{ control.touched }}
+ *   `
+ * })
+ * ```
+ */
+declare function onStoryBootstrappedTrigger(targetSelector: string, eventName: string): {
+    provide: i0.InjectionToken<readonly ((compRef: ComponentRef<any>) => void)[]>;
+    useValue: (componentRef: ComponentRef<any>) => void;
+    multi: boolean;
+};
+
+declare class StoryPreferencesAccessorService implements TheSeamPreferencesAccessor {
+    /**
+     * Gets a preference.
+     */
+    get(name: string): Observable<string>;
+    /**
+     * Update a preference.
+     */
+    update(name: string, value: string): Observable<string>;
+    /**
+     * Delete a preference.
+     */
+    delete(name: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StoryPreferencesAccessorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StoryPreferencesAccessorService>;
+}
+
+export { STORY_INITIAL_ROUTE_URL, StoryEmptyComponent, StoryEmptyWithRouteComponent, StoryHelperComponentsModule, StoryInitialRouteModule, StoryInitialRouteService, StoryModalContainerComponent, StoryPreferencesAccessorService, StoryToastrService, argsToTpl, buttonTypeArgType, onStoryBootstrappedTrigger, routeButton, routesArgType, sizeArgType, storyInitialRouteFactory, themeArgType, themeWithOutlineArgType };
+export type { ArgsTplOptions, ArgsTplParts };

package/styles/bootstrap/_bs-variables.scss

@@ -1,3 +1,5 @@
+@use "sass:map";
+
 //
 // This file should only contain changes to bootstrap variables
 //
@@ -23,7 +25,7 @@ $black:    #000 !default;
 
 $grays: ();
 // stylelint-disable-next-line scss/dollar-variable-default
-$grays: map-merge(
+$grays: map.merge(
   (
     "100": $gray-100,
     "200": $gray-200,
@@ -53,7 +55,7 @@ $cyan:    #17a2b8 !default;
 
 $colors: ();
 // stylelint-disable-next-line scss/dollar-variable-default
-$colors: map-merge(
+$colors: map.merge(
   (
     "blue":       $blue,
     "indigo":     $indigo,
@@ -84,7 +86,7 @@ $lightgray:     $gray-300 !default;
 
 $theme-colors: () !default;
 // stylelint-disable-next-line scss/dollar-variable-default
-$theme-colors: map-merge(
+$theme-colors: map.merge(
   (
     "primary":    $primary,
     "secondary":  $secondary,

package/styles/vendor/ngx-datatable/_ngx-datatable.scss

@@ -1,5 +1,5 @@
 @import './variables';
-@import '@marklb/ngx-datatable/index';
+// @import '@marklb/ngx-datatable/index';
 
 .ngx-datatable {
   background: $datatable-background;

package/styles/vendor/ngx-datatable/_themes/bootstrap/_variables.scss

@@ -1,3 +1,5 @@
+@use 'sass:color';
+
 $datatable-font-size: 16px !default;
 $datatable-default-border-width: $border-width !default;
 
@@ -174,10 +176,10 @@ $datatable-summary-row-font-weight: bold !default;
 // Action Menu Button Styles
 $datatable-action-button-background: $primary !default;
 $datatable-action-button-border: $datatable-action-button-background !default;
-$datatable-action-button-hover-background: darken($datatable-action-button-background, 7.5%) !default;
-$datatable-action-button-hover-border: darken($datatable-action-button-border, 10%) !default;
-$datatable-action-button-active-background: darken($datatable-action-button-background, 10%) !default;
-$datatable-action-button-active-border: darken($datatable-action-button-border, 12.5%) !default;
+$datatable-action-button-hover-background: color.adjust($datatable-action-button-background, $lightness: -7.5%, $space: hsl) !default;
+$datatable-action-button-hover-border: color.adjust($datatable-action-button-border, $lightness: -10%, $space: hsl) !default;
+$datatable-action-button-active-background: color.adjust($datatable-action-button-background, $lightness: -10%, $space: hsl) !default;
+$datatable-action-button-active-border: color.adjust($datatable-action-button-border, $lightness: -12.5%, $space: hsl) !default;
 
 $datatable-action-button-color: color-yiq($datatable-action-button-background) !default;
 $datatable-action-button-hover-color: color-yiq($datatable-action-button-hover-background) !default;