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

package/tooltip/index.d.ts

@@ -0,0 +1,118 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, TemplateRef, ElementRef, OnInit, OnChanges, SimpleChanges } from '@angular/core';
+import { AnimationEvent } from '@angular/animations';
+import { Subject } from 'rxjs';
+import * as i1 from '@angular/common';
+import * as i2 from '@angular/cdk/overlay';
+
+type TheSeamTooltipPlacement = 'top' | 'top-left' | 'top-right' | 'bottom' | 'bottom-left' | 'bottom-right' | 'left' | 'left-top' | 'left-bottom' | 'right' | 'right-top' | 'right-bottom' | 'auto';
+declare class TheSeamTooltipComponent implements OnDestroy {
+    content: string | TemplateRef<any> | null;
+    tooltipClass?: string;
+    context?: any;
+    placement: TheSeamTooltipPlacement;
+    actualPlacement?: TheSeamTooltipPlacement;
+    tooltipId?: string;
+    triggerElement?: HTMLElement;
+    /** A subject emitting after the tooltip enters the view. */
+    readonly _afterEnter: Subject<void>;
+    /** A subject emitting after the tooltip exits the view. */
+    readonly _afterExit: Subject<void>;
+    get hostClasses(): string;
+    innerElement: ElementRef;
+    arrowElement: ElementRef;
+    ngOnDestroy(): void;
+    get isStringContent(): boolean;
+    get isTemplateContent(): boolean;
+    get templateContent(): TemplateRef<any> | null;
+    private _getPlacementClass;
+    private _setArrowPosition;
+    /** Emit lifecycle events based on animation `start` callback. */
+    _onAnimationStart(event: AnimationEvent): void;
+    /** Emit lifecycle events based on animation `done` callback. */
+    _onAnimationDone(event: AnimationEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamTooltipComponent, "seam-tooltip", never, { "content": { "alias": "content"; "required": false; }; "tooltipClass": { "alias": "tooltipClass"; "required": false; }; "context": { "alias": "context"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "actualPlacement": { "alias": "actualPlacement"; "required": false; }; "tooltipId": { "alias": "tooltipId"; "required": false; }; "triggerElement": { "alias": "triggerElement"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TheSeamTooltipTrigger = 'hover' | 'focus' | 'both';
+type TheSeamTooltipPlacementInput = TheSeamTooltipPlacement | TheSeamTooltipPlacement[] | string;
+/**
+ * A custom tooltip directive that replaces \`ngbTooltip\` with zero dependencies.
+ * Supports both string and template content with full Bootstrap 4.6 compatibility.
+ *
+ * ## Features
+ * - **String & Template Content**: Support for both simple text and complex HTML content
+ * - **Multiple Triggers**: Hover, focus, or both
+ * - **Flexible Positioning**: 12 placement options with auto-fallback
+ * - **Configurable Timing**: Customizable show/hide delays
+ * - **Bootstrap Compatible**: Uses Bootstrap 4.6 classes for seamless integration
+ * - **Accessibility**: Full ARIA support and keyboard navigation
+ * - **Performance**: Lazy creation and proper cleanup
+ *
+ * ## Migration from ngbTooltip
+ * ```typescript
+ * // Before
+ * <button ngbTooltip="Help text" placement="top" tooltipClass="custom">
+ *
+ * // After
+ * <button seamTooltip="Help text" placement="top" tooltipClass="custom">
+ * ```
+ */
+declare class TheSeamTooltipDirective implements OnInit, OnChanges, OnDestroy {
+    private readonly _elementRef;
+    private readonly _viewContainerRef;
+    private readonly _overlay;
+    private readonly _ngUnsubscribe;
+    private readonly _tooltipId;
+    seamTooltip: string | TemplateRef<any> | null;
+    tooltipClass?: string;
+    placement?: TheSeamTooltipPlacementInput | null;
+    container?: string | HTMLElement;
+    get disableTooltip(): boolean;
+    set disableTooltip(val: boolean);
+    private readonly _disableTooltip;
+    get showDelay(): number;
+    set showDelay(val: number);
+    private readonly _showDelay;
+    get hideDelay(): number;
+    set hideDelay(val: number);
+    private readonly _hideDelay;
+    trigger: TheSeamTooltipTrigger;
+    private _active;
+    private _overlayRef;
+    private _compRef;
+    private _showTimeoutId;
+    private _hideTimeoutId;
+    private _eventListenersSubject;
+    private _documentKeydownSubject;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private _setupEventListeners;
+    private _scheduleShow;
+    private _scheduleHide;
+    private _clearTimeouts;
+    private _showTooltip;
+    private _setupDocumentKeydownListener;
+    private _closeTooltip;
+    private _resetTooltip;
+    tooltipOpen(): boolean;
+    private _parsePlacementInput;
+    private _isValidPlacement;
+    private _getOverlayPosition;
+    private _getPositions;
+    private _getPositionForPlacement;
+    private _getPlacementFromConnectionPair;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamTooltipDirective, "[seamTooltip]", ["seamTooltip"], { "seamTooltip": { "alias": "seamTooltip"; "required": false; }; "tooltipClass": { "alias": "tooltipClass"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "container": { "alias": "container"; "required": false; }; "disableTooltip": { "alias": "disableTooltip"; "required": false; }; "showDelay": { "alias": "showDelay"; "required": false; }; "hideDelay": { "alias": "hideDelay"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TheSeamTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamTooltipModule, never, [typeof i1.CommonModule, typeof i2.OverlayModule, typeof TheSeamTooltipComponent, typeof TheSeamTooltipDirective], [typeof TheSeamTooltipDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamTooltipModule>;
+}
+
+export { TheSeamTooltipComponent, TheSeamTooltipDirective, TheSeamTooltipModule };
+export type { TheSeamTooltipPlacement, TheSeamTooltipPlacementInput, TheSeamTooltipTrigger };

package/unsaved-changes-dialog/index.d.ts

@@ -1,5 +1,24 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/unsaved-changes-dialog" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { CanDeactivateFn } from '@angular/router';
+
+declare class UnsavedChangesDialogComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnsavedChangesDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UnsavedChangesDialogComponent, "seam-unsaved-changes-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class TheSeamUnsavedChangesDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamUnsavedChangesDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamUnsavedChangesDialogModule, never, [typeof UnsavedChangesDialogComponent], [typeof UnsavedChangesDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamUnsavedChangesDialogModule>;
+}
+
+declare abstract class UnsavedChangesCanDeactivate {
+    abstract unsavedChangesCanDeactivate(): boolean;
+    __unloadNotification($event: any): true | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnsavedChangesCanDeactivate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UnsavedChangesCanDeactivate, never, never, {}, {}, never, never, true, never>;
+}
+
+declare const UnsavedChangesDialogGuard: CanDeactivateFn<UnsavedChangesCanDeactivate>;
+
+export { TheSeamUnsavedChangesDialogModule, UnsavedChangesCanDeactivate, UnsavedChangesDialogComponent, UnsavedChangesDialogGuard };

package/utils/index.d.ts

@@ -1,5 +1,434 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/utils" />
-export * from './public-api';
+import { CdkDrag } from '@angular/cdk/drag-drop';
+import { ElementRef, QueryList } from '@angular/core';
+import { AbstractControl, ValidatorFn } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { ActivatedRoute, Data, ActivatedRouteSnapshot } from '@angular/router';
+import { FeatureCollection, GeoJSON, Feature, GeoJsonProperties, Geometry, Polygon, MultiPolygon } from 'geojson';
+import { AreaUnits } from '@turf/helpers';
+import { Buffer } from 'buffer/';
+
+/**
+ * Finds the closest CdkDrag to an element by looking at the DOM.
+ * @param element Element relative to which to look for a cdkDrag.
+ * @param openDialogs References to the currently available cdkDrag.
+ */
+declare function getClosestWidgetCdkDrag(element: ElementRef<HTMLElement>, dragDirectives: CdkDrag<any>[]): CdkDrag<any> | null | undefined;
+
+/**
+ * Get the name of the control.
+ *
+ * Example:
+ *
+ * ```js
+ * const group = new FormGroup({
+ *  name: new Control(),
+ *  age: new Control()
+ * })
+ *
+ * for (const c of group.controls) {
+ *   console.log(getControlName(c))
+ * }
+ *
+ * // Output:
+ * // >> 'name'
+ * // >> 'age'
+ * ```
+ */
+declare function getControlName(c: AbstractControl): string | null;
+
+/**
+ * Get the path to a control.
+ *
+ * The path is built by walking back the `parent` properties until `parent` is
+ * `null`.
+ *
+ * Example:
+ *
+ * ```js
+ * const group = new FormGroup({
+ *   name: new FormControl(),
+ *   address: new FormGroup({
+ *     city: new FormControl(),
+ *     state: new FormControl()
+ *   })
+ * })
+ *
+ * const control = group.get('address.city')
+ * console.log(getControlPath(control))
+ *
+ * // Output:
+ * >> 'address.city'
+ * ```
+ *
+ */
+declare function getControlPath(c: AbstractControl, path?: string): string | null;
+
+/**
+ * Observe the changed state of the input value from the time this function is
+ * called.
+ *
+ * When this function is called the value is stored. Each time the control's
+ * value changes the value is compared with the initial value. Currenly the
+ * values are compared as stringified objects using `JSON.stringify`.
+ *
+ * TODO: Allow the value compare implementation to be optionally changed.
+ */
+declare function observeControlIsDifferent(control: AbstractControl): Observable<boolean>;
+
+/**
+ * Observe the status of a control using a work around for status not changing
+ * after pending.
+ */
+declare function observeControlStatus(control: AbstractControl): Observable<string>;
+
+/**
+ * Observe the valid state of a control.
+ *
+ * By default `waitOnPending` is false and the control states map to:
+ *  'VALID' => true
+ *  'INVALID' => false
+ *  'PENDING' => false
+ *
+ * If `waitOnPending` is true the valid result when 'PENDING' remains the same
+ *  as it was before 'PENDING' until it is no longer 'PENDING'.
+ */
+declare function observeControlValid(control: AbstractControl, waitOnPending?: boolean): Observable<boolean>;
+
+/**
+ * Observe the value of a control with the previous.
+ */
+declare function observeControlValueChange(control: AbstractControl): Observable<{
+    previous: any;
+    current: any;
+}>;
+
+/**
+ * Observe the value of a control.
+ */
+declare function observeControlValue<T = any>(control: AbstractControl): Observable<T>;
+
+/**
+ * Wait on the status of a form control to not be `'PENDING'`.
+ *
+ * NOTE: This function is mainly just a work around for an issue where
+ *  `statusChanges` sometimes emits `'Pending'` without emitting another state
+ *  when complete. Seems to happen with async validators if the value changes
+ *  before completing, even if the validator completes(subscription `complete`
+ *  if observable).
+ */
+declare function waitOnNonPendingStatus(control: AbstractControl): Observable<string>;
+
+/**
+ * Check if control has a required control.
+ *
+ * ----------------------------------------------------------------------------
+ * NOTE: I am not sure about if this should be used or not.
+ *
+ * From my understanding this assumes that all the validators do not have some
+ * unexpected side-effect from being called like this. It could be argued that
+ * the validator is flawed and should be fixed if that is the case, but I am not
+ * convinced that is correct yet.
+ *
+ * An example that I think is valid for this argument: A FormControl configured
+ * to only check validators when a specific condition happens, because of a
+ * reason that it has to do a long process. In that situation should this
+ * function be smart enough to consider that or is it up to the validator to
+ * consider this function possibly being used.
+ *
+ * This seems to assume the required validator will always be a synchronous
+ * validator. That is a valid assumption if thinking about showing a required
+ * state in the UI, but a FormControl does not neccessarily have to be used in
+ * UI. So, I think it could be valid to have an async validator that uses the
+ * name `required` for it error, but I do not have a good example, so I could be
+ * wrong.
+ * ----------------------------------------------------------------------------
+ *
+ * Source: https://gist.github.com/jsdevtom/5589af349a395b37e699b67417ef025b
+ * @experimental
+ * @ignore
+ */
+declare function hasRequiredControl(abstractControl: AbstractControl): boolean;
+
+declare function isEmptyInputValue(value: any): boolean;
+
+declare function mapEach<T, R>(predicate: (value: T) => R): (source$: Observable<T[]>) => Observable<R[]>;
+
+/**
+ * Like tap, but only calls predicate on first emission.
+ */
+declare function tapFirst<T>(predicate: (value: T) => void): (source$: Observable<T>) => Observable<T>;
+
+interface IActivatedRouteWithData {
+    route: ActivatedRoute;
+    data: Data;
+}
+declare function activatedRoutesWithDataProperty(prop: string, mustHaveDefined?: boolean): (source$: Observable<ActivatedRoute>) => Observable<IActivatedRouteWithData[]>;
+
+declare function leafChildRoute(activatedRoute: ActivatedRoute): ActivatedRoute;
+
+declare function routeSnapshotPathRelative(route: ActivatedRouteSnapshot): string;
+
+declare function routeSnapshotPathFull(route: ActivatedRouteSnapshot): string;
+
+declare function willHaveDataProp(route: ActivatedRoute, prop: string): boolean;
+
+declare function isEmptyUrlRoute(activatedRoute: ActivatedRoute): boolean;
+
+declare function coerceFeatureCollection(value: any): FeatureCollection | null;
+
+/**
+ *
+ */
+declare function geoJsonToArea(geoJson: GeoJSON | Feature<any, GeoJsonProperties> | FeatureCollection<any, GeoJsonProperties> | Geometry, units?: AreaUnits): number;
+
+declare const IS_FEATURE_COLLECTION_VALIDATOR_NAME = "is-feature-collection";
+declare function isFeatureCollectionValidator(): ValidatorFn;
+
+/**
+ * Returns true if the GeoJSON is only specifies geometries.
+ */
+declare function isOnlyGeometryTypes(featureCollection: FeatureCollection, types: Geometry['type'][]): boolean;
+
+declare const IS_ONLY_GEOMETRY_TYPES_VALIDATOR_NAME = "is-only-geometry-types";
+declare function isOnlyGeometryTypesValidator(types: Geometry['type'][]): ValidatorFn;
+
+/**
+ * Merge Polygon and MultiPolygon geometries into a single MultiPolygon. Any
+ * properties, other than 'coordinates', of the Polygons and MultiPolygons will
+ * be lost.
+ *
+ * NOTE: Polygons and MultPolygons in a GeometryCollection will not be merged.
+ */
+declare function mergePolygons(featureCollection: FeatureCollection): void;
+
+declare const MIN_MAX_POINTS_VALIDATOR_NAME = "min-max-points";
+declare function minMaxPointsValidator(min?: number | undefined, max?: number | undefined): ValidatorFn;
+
+declare const NO_EMPTY_FEATURE_COLLECTION_VALIDATOR_NAME = "no-empty-feature-collection";
+declare function noEmptyFeatureCollectionValidator(): ValidatorFn;
+
+declare const NO_INNER_RINGS_VALIDATOR_NAME = "no-inner-rings";
+/**
+ * Validates that a FeatureCollection does not contain any Polygon with inner
+ * rings("holes").
+ *
+ * NOTE: Only considers Polygon and MultiPolygon. Does not consider
+ * GeometryCollection.
+ */
+declare function noInnerRingsValidator(): ValidatorFn;
+
+declare const NO_KINKS_VALIDATOR_NAME = "no-kinks";
+declare function noKinksValidator(): ValidatorFn;
+
+/**
+ * Reads a File, or buffer of file content, in GeoJSON or ESRI Shapefile format
+ * and returns a GeoJSON `FeatureCollection`.
+ */
+declare function readGeoFile(fileOrBuffer: File | ArrayBuffer | Buffer): Promise<FeatureCollection>;
+
+/**
+ * Split all MultiPolygon into Polygon. Any properties, other than
+ * 'coordinates', of the MultiPolygons will be lost.
+ *
+ * NOTE: MultiPolygons in a GeometryCollection will not be split.
+ */
+declare function splitMultiPolygons(featureCollection: FeatureCollection): void;
+
+/**
+ * Close all polygons in the GeoJSON.
+ *
+ * Google Maps requires that polygons be closed, but not all libraries have that
+ * requirement. This may add redundent points to the GeoJSON, but it will ensure
+ * that the GeoJSON is valid for Google Maps.
+ */
+declare function closePolygons(geoJson: FeatureCollection | Feature | Polygon | MultiPolygon): void;
+
+/**
+  Moves the item to the new position in the input array. Useful for huge arrays
+  where absolute performance is needed.
+
+  @param array - The array to modify.
+  @param fromIndex - The index of item to move. If negative, it will begin that
+  many elements from the end.
+  @param toIndex - The index of where to move the item. If negative, it will
+  begin that many elements from the end.
+  @example
+  ```
+  import { arrayMoveMutable } from '@theseam/ui-common/utils';
+
+  const input = ['a', 'b', 'c'];
+  arrayMoveMutable(input, 1, 2);
+  console.log(input);
+  //=> ['a', 'c', 'b']
+  ```
+*/
+declare function arrayMoveMutable(array: unknown[], fromIndex: number, toIndex: number): void;
+/**
+  Clones the given `array`, moves the item to a new position in the new array,
+  and then returns the new array. The given `array` is not mutated.
+
+  @param array - The array with the item to move.
+  @param fromIndex - The index of item to move. If negative, it will begin that
+  many elements from the end.
+  @param toIndex - The index of where to move the item. If negative, it will
+  begin that many elements from the end.
+  @returns A new array with the item moved to the new position.
+  @example
+  ```
+  import { arrayMoveImmutable } from '@theseam/ui-common/utils';
+
+  const input = ['a', 'b', 'c'];
+  const array1 = arrayMoveImmutable(input, 1, 2);
+  console.log(array1);
+  //=> ['a', 'c', 'b']
+
+  const array2 = arrayMoveImmutable(input, -1, 0);
+  console.log(array2);
+  //=> ['c', 'a', 'b']
+
+  const array3 = arrayMoveImmutable(input, -2, -3);
+  console.log(array3);
+  //=> ['b', 'a', 'c']
+  ```
+*/
+declare function arrayMoveImmutable<ValueType>(array: readonly ValueType[], fromIndex: number, toIndex: number): ValueType[];
+
+declare function calcPercentage(total: number, n: number): number;
+
+/**
+ * Polyfil for `Element.toggleAttribute`
+ *
+ * Toggles a value without a value. Useful for attributes, such as `disabled`,
+ * `readonly`, and `hidden`, that only needs to exist on the `Element` without
+ * requiring a value.
+ *
+ * Most browsers natively support this feature, but IE, which we still try to
+ * support for at least the main parts of the app, has "Unknown" support of this
+ * feature. Until IE support is dropped this polyfil should be used to toggle an
+ * attribute.
+ *
+ * Source:
+ * https://developer.mozilla.org/en-US/docs/Web/API/Element/toggleAttribute#Polyfill
+ */
+declare function toggleAttribute(element: HTMLElement, name: string, force: boolean): boolean;
+
+/**
+ *
+ */
+declare function getAttribute<E extends HTMLElement>(element: E, name: string): string | null;
+
+declare const phoneNumberMask: (string | RegExp)[];
+
+declare function isNullOrUndefined<T>(value: T | null | undefined): value is (null | undefined);
+
+declare function isNullOrUndefinedOrEmpty(value: string | null | undefined, trim?: boolean): value is (string | null | undefined);
+
+declare function loadStyle(content: string): Promise<HTMLStyleElement>;
+
+declare function loadStyleSheet(path: string): Promise<HTMLLinkElement>;
+
+/** Returns object without property */
+declare function withoutProperty<T, K extends keyof T>(obj: T, propName: K): Pick<T, Exclude<keyof T, K>>;
+/** Returns object without properties */
+declare function withoutProperties<T, K extends keyof T>(obj: T, propNames: K[]): Pick<T, Exclude<keyof T, K>>;
+/** Delete property of object */
+declare function deleteProperty<T extends object, K extends keyof T>(obj: T, propName: K): void;
+/** Delete properties of object */
+declare function deleteProperties<T extends object, K extends keyof T>(obj: T, propNames: K[]): void;
+
+declare function readFileAsync(file: any): Promise<ArrayBuffer | null>;
+declare function readFileAsDataUrlAsync(file: Blob): Promise<string | null>;
+declare function fileBufferToBlob(fileBuffer: Buffer, defaultMime?: string): Promise<Blob>;
+declare function fileBufferToObjectUrl(fileBuffer: Buffer, defaultMime?: string): Promise<string>;
+interface IFileData {
+    ext?: string;
+    mime?: string;
+    blob: Blob;
+}
+declare function fileDataFromBuffer(fileBuffer: Buffer | Uint8Array | ArrayBuffer, defaultMime?: string): Promise<IFileData>;
+declare function openBlob(blob: Blob, target?: string, filename?: string): void;
+
+declare function notNullOrUndefined<T>(value: T | null | undefined): value is T;
+
+declare function notNullOrUndefinedOrEmpty(value: string | null | undefined, trim?: boolean): value is string;
+
+declare function waitOnConditionAsync(condition: () => boolean, timeoutDuration?: number, throwOnTimeout?: boolean): Promise<any>;
+
+type PollingActionFn<R> = () => R | Observable<R>;
+declare class PollingTickerOptions {
+    emitOnInit?: boolean;
+}
+/**
+ * Call an action and emits the result to its subscriber on an interval or when
+ * ticker emits. When the ticker emits, the interval time will reset.
+ *
+ * When subscribed to, the action will be called and emitted right away unless
+ * the `emitOnInit` option is set to false.
+ */
+declare function pollingTicker<R>(action: PollingActionFn<R>, pollingInterval?: number, ticker?: Observable<number | void>, options?: PollingTickerOptions): Observable<R>;
+
+declare class Refreshable<T> {
+    private _initialized;
+    private _pollingInterval;
+    private _ticker;
+    private _pending;
+    data$: Observable<T>;
+    pending$: Observable<boolean>;
+    constructor(action: () => (T | Observable<T>), pollingInterval?: number);
+    get initialized(): boolean;
+    /**
+     * Intercepts the action call to monitor pending state
+     */
+    private _actionHandler;
+    /**
+     * Selects the data observable
+     */
+    select(refresh?: boolean): Observable<T>;
+    refresh(): Observable<void>;
+}
+
+declare function wrapIntoObservable<T>(value: T | Promise<T> | Observable<T>): Observable<T>;
+
+declare function isAbsoluteUrl(url: string): boolean;
+
+type SubscriberCountChangedFn = (description: string, count: number, reason: 'subscribed' | 'unsubscribed') => void;
+/**
+ * This is just for helping debug observables that aren't being unsubscribed
+ * from correctly.
+ *
+ * If description is 'foo' then you can check the how many observers are
+ * subscribed with the expression `__subscriberCounts['foo']`. In a debugger you
+ * can add the expression to the "Watch" expressions or in Chrome Devtools
+ * Console you can add it to the live expressions(Add live expressions by
+ * clicking the eye the the left of the Console filter input).
+ */
+declare function subscriberCount<T>(sourceObservable: Observable<T>, description: string, countChangedFn?: SubscriberCountChangedFn | undefined | null): Observable<T>;
+
+declare function hasProperty<T extends object, K extends keyof T>(style: T, prop: K): style is T & Required<Record<K, Exclude<T[K], undefined>>>;
+
+/**
+ *
+ */
+declare function hasAttribute<E extends HTMLElement>(element: E, name: string): boolean;
+
+declare function observeQueryList<T>(queryList: QueryList<T>, emitCurrentValue?: boolean): Observable<T[]>;
+
+declare function padEnd(stringToPad: string, paddingLength?: number | undefined, paddingChars?: string | undefined): string;
+
+declare function padStart(stringToPad: string, paddingLength?: number | undefined, paddingChars?: string | undefined): string;
+
+declare function createPadding(len: number, chars: string): string;
+
+declare function isNumeric(value: any): boolean;
+
+/**
+ * Returns the number of fractional digits.
+ *
+ * NOTE: This is intended for input validation, so trailing 0's will be included
+ * in the total. Also, localization is not considered, so '.' is assumed to be
+ * the fractional separator.
+ */
+declare function fractionalDigitsCount(value: string): number | null;
+
+export { IS_FEATURE_COLLECTION_VALIDATOR_NAME, IS_ONLY_GEOMETRY_TYPES_VALIDATOR_NAME, MIN_MAX_POINTS_VALIDATOR_NAME, NO_EMPTY_FEATURE_COLLECTION_VALIDATOR_NAME, NO_INNER_RINGS_VALIDATOR_NAME, NO_KINKS_VALIDATOR_NAME, PollingTickerOptions, Refreshable, activatedRoutesWithDataProperty, arrayMoveImmutable, arrayMoveMutable, calcPercentage, closePolygons, coerceFeatureCollection, createPadding, deleteProperties, deleteProperty, fileBufferToBlob, fileBufferToObjectUrl, fileDataFromBuffer, fractionalDigitsCount, geoJsonToArea, getAttribute, getClosestWidgetCdkDrag, getControlName, getControlPath, hasAttribute, hasProperty, hasRequiredControl, isAbsoluteUrl, isEmptyInputValue, isEmptyUrlRoute, isFeatureCollectionValidator, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumeric, isOnlyGeometryTypes, isOnlyGeometryTypesValidator, leafChildRoute, loadStyle, loadStyleSheet, mapEach, mergePolygons, minMaxPointsValidator, noEmptyFeatureCollectionValidator, noInnerRingsValidator, noKinksValidator, notNullOrUndefined, notNullOrUndefinedOrEmpty, observeControlIsDifferent, observeControlStatus, observeControlValid, observeControlValue, observeControlValueChange, observeQueryList, openBlob, padEnd, padStart, phoneNumberMask, pollingTicker, readFileAsDataUrlAsync, readFileAsync, readGeoFile, routeSnapshotPathFull, routeSnapshotPathRelative, splitMultiPolygons, subscriberCount, tapFirst, toggleAttribute, waitOnConditionAsync, waitOnNonPendingStatus, willHaveDataProp, withoutProperties, withoutProperty, wrapIntoObservable };
+export type { IActivatedRouteWithData, IFileData, PollingActionFn, SubscriberCountChangedFn };

package/validators/index.d.ts

@@ -1,5 +1,49 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/validators" />
-export * from './public-api';
+import { FormControl, ValidatorFn } from '@angular/forms';
+import { Observable } from 'rxjs';
+
+/**
+ * Validates that value matches on of the following:
+ *  ''             // empty string
+ *  'xxxxxxxxx'    // 'x' is a number
+ *  'xx-xxxxxxx'   // 'x' is a number
+ *  'xxx-xx-xxxx'  // 'x' is a number
+ */
+declare function taxIdValidator(control: FormControl): {
+    taxId: {};
+} | null;
+
+/**
+ * Validates that an email already exists.
+ */
+declare function emailExistsValidator(emailExists: (email: string) => Promise<boolean> | Observable<boolean> | boolean): (control: FormControl) => Observable<{
+    emailExists: {};
+} | null> | Promise<{
+    emailExists: {};
+} | null>;
+
+/**
+ * Validates that a value is a valid phone number length.
+ */
+declare function phoneLengthValidator(control: FormControl): {
+    phoneLength: {};
+} | null;
+
+declare const DECIMAL_REGEX: RegExp;
+/**
+ * Validates control value is a valid decimal number.
+ *
+ * NOTE: This does not allow any js valid decimal number. It only accepts them
+ * in a format expected by our backend.
+ */
+declare const decimalValidator: ValidatorFn;
+
+declare const INTEGER_REGEX: RegExp;
+/**
+ * Validates control value is a valid integer number.
+ *
+ * NOTE: This does not allow any js valid integer number. It only accepts them
+ * in a format expected by our backend.
+ */
+declare const integerValidator: ValidatorFn;
+
+export { DECIMAL_REGEX, INTEGER_REGEX, decimalValidator, emailExistsValidator, integerValidator, phoneLengthValidator, taxIdValidator };

package/vertical-list-filter/index.d.ts

@@ -1,5 +1,31 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/vertical-list-filter" />
-export * from './public-api';
+import * as _angular_cdk_testing from '@angular/cdk/testing';
+import { ComponentHarness } from '@angular/cdk/testing';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+
+declare class TheSeamVerticalListFilterHarness extends ComponentHarness {
+    static hostSelector: string;
+    _clearOptionElement: () => Promise<_angular_cdk_testing.TestElement | null>;
+    clickValue(value: string): Promise<void>;
+    filterValue(): Promise<string | undefined>;
+    hasClearOption(): Promise<boolean>;
+    clearFilter(): Promise<void>;
+}
+
+declare const FILTER_VALUES: string[];
+declare class TheSeamVerticalListFilterComponent {
+    readonly _values: string[];
+    showClearOption: boolean;
+    get filterValue(): string | undefined;
+    set filterValue(value: string | undefined);
+    private readonly _filterValue;
+    readonly filterValue$: Observable<string | undefined>;
+    get _filterValueAttr(): string | undefined;
+    constructor();
+    characterClick(character: string): void;
+    clearFilter(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamVerticalListFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamVerticalListFilterComponent, "seam-vertical-list-filter", never, { "showClearOption": { "alias": "showClearOption"; "required": false; }; "filterValue": { "alias": "filterValue"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { FILTER_VALUES, TheSeamVerticalListFilterComponent, TheSeamVerticalListFilterHarness };