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

package/graphql/index.d.ts

@@ -1,5 +1,336 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/graphql" />
-export * from './public-api';
+import { DocumentNode, ValueNode, Token } from 'graphql/language';
+import * as graphql from 'graphql';
+import { DocumentNode as DocumentNode$1, ValueNode as ValueNode$1, OperationDefinitionNode, VariableDefinitionNode, VariableNode, ArgumentNode, FieldNode, Token as Token$1, GraphQLSchema } from 'graphql';
+import * as _apollo_client from '@apollo/client';
+import { Operation, InMemoryCache } from '@apollo/client';
+import { Observable } from 'rxjs';
+import { DatatableComponent, SortItem, TheSeamPageInfo, ColumnsDataFilterState, TheSeamColumnsDataFilterDateSearchFormState, TheSeamColumnsDataFilterDateSearchOptions, TheSeamColumnsDataFilterNumericSearchFormState, TheSeamColumnsDataFilterTextSearchFormState, SortEvent } from '@theseam/ui-common/datatable';
+import { ApolloQueryResult, DocumentNode as DocumentNode$2, TypedDocumentNode } from '@apollo/client/core';
+import * as apollo_angular from 'apollo-angular';
+import { QueryRef, WatchQueryOptions, Apollo } from 'apollo-angular';
+import { DataFilterState } from '@theseam/ui-common/data-filters';
+import * as i0 from '@angular/core';
+import { InjectionToken, EventEmitter } from '@angular/core';
+import { OperationVariables } from '@apollo/client/core/types';
+import * as _theseam_ui_common_graphql from '@theseam/ui-common/graphql';
+
+declare function containsVariable(node: DocumentNode | ValueNode, variableName: string): boolean;
+
+declare function gqlVar(varName: string): {
+    gqlVar: string;
+};
+
+declare function inlineVariable(query: DocumentNode$1, variableName: string, variableValue: ValueNode$1): DocumentNode$1;
+
+declare function parseComments(ast: DocumentNode): Token[];
+
+declare enum HintsKind {
+    OperationDefinition = "OperationDefinition",
+    Field = "Field",
+    VariableDefinition = "VariableDefinition",
+    Variable = "Variable",
+    Argument = "Argument"
+}
+
+interface HintsToken {
+    node: OperationDefinitionNode | VariableDefinitionNode | VariableNode | ArgumentNode | FieldNode;
+    hints: string[];
+    kind: HintsKind;
+}
+
+interface QueryProcessingVariablesConfig {
+    removeIfNotDefined?: string[];
+    removeIfNotUsed?: string[];
+    inline?: string[];
+}
+interface QueryProcessingConfig {
+    variables: QueryProcessingVariablesConfig;
+    /**
+     * If skip and take are found, they will be removed
+     */
+    disablePaging?: boolean;
+}
+
+type GqlDatatableAccessor = Pick<DatatableComponent, 'page' | 'sort' | 'sorts' | 'filterStates'> & {
+    ngxDatatable: {
+        offset: number;
+        pageSize: number;
+        limit?: number;
+        count: number;
+    };
+};
+
+type EmptyObject = {
+    [key: string]: any;
+};
+
+declare const HINT_PREFIX_REGEX: RegExp;
+declare const HINT_NAMES_CAPTURE_REGEX: RegExp;
+/**
+ * If AST loc has startToken prop then return same AST else reparse with config
+ * to contain comments and loc at each node.
+ */
+declare function parseAst(ast: DocumentNode$1): DocumentNode$1;
+declare function isCommentToken(token: Token$1): boolean;
+declare function isHintToken(token: Token$1): boolean;
+declare function isInlineComment(token: Token$1): boolean;
+declare function hintNamesFromHintToken(token: Token$1): string[];
+declare function getTokenAppliesTo(token: Token$1): Token$1 | null;
+declare function createHintsToken(token: Token$1, node: HintsToken['node'], kind: HintsKind): HintsToken;
+declare function getHintsToken(token: Token$1, ast: DocumentNode$1): HintsToken | null;
+declare function parseHints(ast: DocumentNode$1): HintsToken[];
+
+declare function removeVariableDefinition(query: DocumentNode$1, variableName: string): DocumentNode$1;
+
+declare function removeVariableDefinitionsNotDefined(query: DocumentNode$1, node: OperationDefinitionNode, variables: Operation['variables']): DocumentNode$1;
+
+declare function removeVariable(query: DocumentNode$1, variableName: string): DocumentNode$1;
+
+declare function toGQL(json: any): string;
+
+declare function hintsTokensContainingHint(hintsTokens: HintsToken[], hint: string): HintsToken[];
+
+interface DatatableGraphQLDataMapperResult<TRow = EmptyObject> {
+    rows: TRow[];
+    /**
+     * If data is paged, this is the total number of unpaged rows.
+     */
+    totalCount?: number;
+}
+type DatatableGraphQLDataMapper<TData, TRow = EmptyObject> = (data: TData) => (DatatableGraphQLDataMapperResult<TRow> | Promise<DatatableGraphQLDataMapperResult<TRow>> | Observable<DatatableGraphQLDataMapperResult<TRow>>);
+type DatatableGraphQLVariables = {
+    skip?: number;
+    take?: number;
+} & EmptyObject;
+/**
+ * Partially wraps ApolloClient's QueryRef with some of our datatable boilerplate.
+ *
+ * TODO: Decide how to handle/display errors.
+ */
+declare class DatatableGraphQLQueryRef<TData, TVariables extends DatatableGraphQLVariables = EmptyObject, TRow = EmptyObject> {
+    /** Original ApolloClient's QueryRef. */
+    private readonly _queryRef;
+    /**
+     * How long to wait before refetching from an update to the query or variables.
+     */
+    private readonly _updatesPollDelay;
+    private readonly _variablesSubject;
+    private readonly _observingChangesSubject;
+    /**
+     * Temporary way of tracking total count when paging is disabled.
+     */
+    private _totalCount;
+    private get _observingChanges();
+    private set _observingChanges(value);
+    private _variablesUpdatePending;
+    private readonly _valueChanges;
+    readonly loading$: Observable<boolean>;
+    get updatesPollDelay(): number;
+    get variablesUpdatePending(): boolean;
+    constructor(
+    /** Original ApolloClient's QueryRef. */
+    _queryRef: QueryRef<TData, TVariables>, 
+    /**
+     * How long to wait before refetching from an update to the query or variables.
+     */
+    _updatesPollDelay?: number);
+    rows(mapper: DatatableGraphQLDataMapper<TData, TRow>): Observable<TRow[]>;
+    private _rowsObservable;
+    private _needsToRequeryWithAllRecords;
+    private _resolveRowMapper;
+    getVariables(): TVariables;
+    private _setVariablesImmediate;
+    private _patchVariablesImmediate;
+    setVariables(variables: TVariables): void;
+    patchVariables(variables: Partial<TVariables>): void;
+    refetch(variables?: TVariables): Promise<ApolloQueryResult<TData>>;
+    setQuery(query: DocumentNode$2 | TypedDocumentNode<TData, TVariables>, triggerRefetch?: boolean): void;
+    getOptions(): WatchQueryOptions<TVariables, TData> | undefined;
+    getQueryProcessingConfig(): QueryProcessingConfig | undefined;
+    private _withVariableOverrides;
+}
+
+type MapperContext<TExtraVariables = EmptyObject> = {
+    extraVariables: TExtraVariables;
+} & {
+    [name: string]: any;
+};
+
+interface FilterStateMapperVariables {
+    [name: string]: any;
+}
+interface FilterStateMapperFilter {
+    [name: string]: any;
+}
+type FilterStateMapperResult = {
+    filter: FilterStateMapperFilter;
+    variables: FilterStateMapperVariables;
+} | null;
+type FilterStateMapper = (filterState: DataFilterState, context: MapperContext) => (FilterStateMapperResult | Promise<FilterStateMapperResult> | Observable<FilterStateMapperResult>);
+interface FilterStateMappers {
+    [filterName: string]: FilterStateMapper;
+}
+declare function mapFilterStates(filterStates: DataFilterState[], filterStateMappers: FilterStateMappers, context: MapperContext): Promise<FilterStateMapperResult>;
+
+type SortsMapperResult = {
+    [name: string]: any;
+}[];
+type SortsMapper = (sorts: SortItem[], context: MapperContext) => (SortsMapperResult | Promise<SortsMapperResult> | Observable<SortsMapperResult>);
+declare function observeRowsWithGqlInputsHandling<TData, TRow, GqlVariables extends EmptyObject>(queryRef: DatatableGraphQLQueryRef<TData, GqlVariables, TRow>, rows: Observable<TRow[]>, datatable: Observable<GqlDatatableAccessor | undefined> | Promise<GqlDatatableAccessor | undefined> | GqlDatatableAccessor, extraVariables: Observable<Partial<GqlVariables>> | Promise<Partial<GqlVariables>> | Partial<GqlVariables>, sortsMapper: SortsMapper, filterStateMappers: FilterStateMappers): Observable<TRow[]>;
+
+/**
+ * NOTE: Any of ApolloClient's WatchQueryOptions properties can be set, but I
+ * think our components should only be providing `query` and `variables`. The
+ * rest should be common options shared by all our app's datatables. This may
+ * change if it is determined to be too restrictive.
+ */
+type DatatableQueryOptions<TVariables extends OperationVariables = OperationVariables, TData = any> = Pick<WatchQueryOptions<TVariables, TData>, 'query'> & Pick<WatchQueryOptions<TVariables, TData>, 'variables'> & Pick<WatchQueryOptions<TVariables, TData>, 'context'>;
+interface DatatableGraphqlServiceConfig {
+    /**
+     * Polling interval time in milliseconds.
+     */
+    pollingIntervalTime?: number;
+}
+declare const DATATABLE_GRAPHQL_SERVICE_CONFIG: InjectionToken<DatatableGraphqlServiceConfig>;
+declare class DatatableGraphqlService {
+    private readonly _apollo;
+    private readonly _config;
+    constructor(_apollo: Apollo, _config?: DatatableGraphqlServiceConfig);
+    watchQuery<TData, TVariables extends DatatableGraphQLVariables = EmptyObject, TRow = EmptyObject>(options: DatatableQueryOptions<TVariables>, queryProcessingConfig?: QueryProcessingConfig): DatatableGraphQLQueryRef<TData, TVariables, TRow>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableGraphqlService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatatableGraphqlService>;
+}
+
+declare const DEFAULT_PAGE_SIZE = 20;
+declare function getPageInfo(datatable: GqlDatatableAccessor | null | undefined, defaultPageSize?: number): TheSeamPageInfo;
+
+declare const mapSearchDateColumnsDataFilterStateToGql: (filterState: ColumnsDataFilterState<TheSeamColumnsDataFilterDateSearchFormState, TheSeamColumnsDataFilterDateSearchOptions>, context: MapperContext<any>) => FilterStateMapperResult;
+
+declare const mapSearchNumericColumnsDataFilterStateToGql: (filterState: ColumnsDataFilterState<TheSeamColumnsDataFilterNumericSearchFormState>, context: MapperContext<any>) => FilterStateMapperResult;
+
+declare const mapSearchTextColumnsDataFilterStateToGql: (filterState: ColumnsDataFilterState<TheSeamColumnsDataFilterTextSearchFormState>, context: MapperContext<any>) => FilterStateMapperResult;
+
+declare const baseSchemaFragment: apollo_angular.TypedDocumentNode<unknown, unknown>;
+
+interface WhereItemDef {
+    eq?: any | WhereItem;
+    neq?: any | WhereItem;
+}
+interface WhereItemCollection {
+    and?: WhereItem | WhereItem[] | WhereItemField;
+    or?: WhereItem | WhereItem[] | WhereItemField;
+}
+interface WhereItemField {
+    [field: string]: WhereItemDef;
+}
+type WhereItem = WhereItemCollection | WhereItemField;
+type WhereArg = WhereItem;
+declare function filterWhere<T>(data: T[], where: WhereArg): T[];
+
+declare function skipAndTake<T>(data: T[], skip: number, take: number): T[];
+
+interface FilteredResultsPageInfo {
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+}
+interface FilteredResults<T> {
+    items: T[];
+    pageInfo: FilteredResultsPageInfo;
+    totalCount: number;
+}
+declare function filteredResults<T>(items: T[], args: any): FilteredResults<T>;
+
+declare class MockDatatable implements GqlDatatableAccessor {
+    private readonly _filterStatesSubject;
+    private _sorts;
+    private _rows;
+    private _offset;
+    private _rowHeight;
+    private _bodyHeight;
+    private _scrolledPosV;
+    page: EventEmitter<TheSeamPageInfo>;
+    sort: EventEmitter<SortEvent>;
+    get sorts(): SortItem[];
+    set sorts(value: SortItem[]);
+    readonly filterStates: Observable<DataFilterState[]>;
+    static pageDefaults(dt: any, defaultPageSize?: number): TheSeamPageInfo;
+    get ngxDatatable(): {
+        offset: number;
+        pageSize: number;
+        limit?: number;
+        count: number;
+    };
+    setSorts(v: SortItem[]): void;
+    setFilterStates(v: DataFilterState[]): void;
+    getNumPages(): number;
+    _calcPage(): number;
+    _calcScrolledPosV(): number;
+    getPage(): number;
+    setPage(v: number): void;
+    getPageSize(): number;
+    setRows(v: any[]): void;
+    setScrolledPosV(v: number): void;
+    /**
+     * Returns the height of a row.
+     *
+     * NOTE: This will not be accurate if your rows do not use a single fixed
+     * height for each row.
+     */
+    getRowHeight(): number;
+}
+
+declare function checkRecordsHaveValue(arr: any[] | null, indices: (number | [startIndex: number, endIndex: number])[], testValueCheckProp?: string | null, onlyCheckProvidedIndices?: boolean): void;
+
+/**
+ * Creates an `APOLLO_OPTIONS` provider configured like our apps, except with
+ * the Apollo HttpLink replaced with a custom GraphQL link that queries from the
+ * schema and root provided. The responses to GQL queries should be the same as
+ * responses from our api, but the query features are limited to common features
+ * necessary for tests. Since we use a C# GraphQL api, it would be a lot of
+ * overhead to use that implementation in this project's tests, but you can
+ * check our `graphQLLink` to find what features have been implemented to
+ * hopefully match the result our api would return.
+ *
+ * NOTE: This was created because `ApolloTestingModule` is very limited. We
+ * mostly use queries intended to emit more than once, but `ApolloTestingModule`
+ * can only emit a query response once.
+ */
+declare function createApolloTestingProvider(schema: GraphQLSchema, rootValue: any): {
+    provide: i0.InjectionToken<_apollo_client.ApolloClientOptions<any>>;
+    useFactory: () => {
+        cache: InMemoryCache;
+        link: _apollo_client.ApolloLink;
+        defaultOptions: {
+            watchQuery: {
+                fetchPolicy: string;
+                errorPolicy: string;
+            };
+            query: {
+                fetchPolicy: string;
+                errorPolicy: string;
+            };
+        };
+    };
+};
+
+interface SimpleGqlTestRecord {
+    id: number;
+    name: string;
+}
+declare function createSimpleGqlTestRecord(num: number): SimpleGqlTestRecord;
+declare const simpleGqlTestSchema: graphql.GraphQLSchema;
+declare function createSimpleGqlTestRoot(numRecords: number): {
+    simpleGqlTestRecords: (args?: any) => _theseam_ui_common_graphql.FilteredResults<SimpleGqlTestRecord>;
+};
+declare const SIMPLE_GQL_TEST_QUERY: apollo_angular.TypedDocumentNode<unknown, unknown>;
+interface SimpleGqlTestExtraVariables {
+}
+interface SimpleGqlTestVariables extends SimpleGqlTestExtraVariables {
+    skip?: number;
+    take?: number;
+    order?: any;
+    where?: any;
+}
+
+export { DATATABLE_GRAPHQL_SERVICE_CONFIG, DEFAULT_PAGE_SIZE, DatatableGraphQLQueryRef, DatatableGraphqlService, HINT_NAMES_CAPTURE_REGEX, HINT_PREFIX_REGEX, MockDatatable, SIMPLE_GQL_TEST_QUERY, baseSchemaFragment, checkRecordsHaveValue, containsVariable, createApolloTestingProvider, createHintsToken, createSimpleGqlTestRecord, createSimpleGqlTestRoot, filterWhere, filteredResults, getHintsToken, getPageInfo, getTokenAppliesTo, gqlVar, hintNamesFromHintToken, hintsTokensContainingHint, inlineVariable, isCommentToken, isHintToken, isInlineComment, mapFilterStates, mapSearchDateColumnsDataFilterStateToGql, mapSearchNumericColumnsDataFilterStateToGql, mapSearchTextColumnsDataFilterStateToGql, observeRowsWithGqlInputsHandling, parseAst, parseComments, parseHints, removeVariable, removeVariableDefinition, removeVariableDefinitionsNotDefined, simpleGqlTestSchema, skipAndTake, toGQL };
+export type { DatatableGraphQLDataMapper, DatatableGraphQLDataMapperResult, DatatableGraphQLVariables, DatatableGraphqlServiceConfig, DatatableQueryOptions, FilterStateMapper, FilterStateMapperFilter, FilterStateMapperResult, FilterStateMapperVariables, FilterStateMappers, FilteredResults, FilteredResultsPageInfo, MapperContext, SimpleGqlTestExtraVariables, SimpleGqlTestRecord, SimpleGqlTestVariables, SortsMapper, SortsMapperResult, WhereArg };

package/icon/index.d.ts

@@ -1,5 +1,193 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/icon" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { DoCheck, ElementRef, Renderer2, OnInit } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { IconProp, IconDefinition, SizeProp } from '@fortawesome/fontawesome-svg-core';
+import { ThemeTypes } from '@theseam/ui-common/models';
+import * as _angular_animations from '@angular/animations';
+import * as i4 from '@angular/common';
+import * as i5 from '@fortawesome/angular-fontawesome';
+
+type SeamIcon = IconProp | IconDefinition | string;
+
+type TheSeamIconType = 'borderless-styled-square' | 'styled-square' | 'image-fill' | undefined;
+declare class IconComponent {
+    static ngAcceptInputType_grayscaleOnDisable: BooleanInput;
+    static ngAcceptInputType_disabled: BooleanInput;
+    static ngAcceptInputType_showDefaultOnError: BooleanInput;
+    needToFix: boolean;
+    /** Toggles whether the img/icon will attempt to be grayscale when disabled is true. */
+    grayscaleOnDisable: boolean;
+    /** Toggles the img/icon to grayscale if `grayscaleOnDisable` is true. */
+    disabled: boolean;
+    /**
+     * Placed on the `.seam-icon--fa` and `seam-icon--img` elements.
+     */
+    iconClass: string | undefined | null;
+    /**
+     * The icon to display.
+     *
+     * If the input icon is a string an `img` element will be used with icon as `src`.
+     * If the input is not a string it will be assumed to be a font-awesome IconProp object.
+     */
+    get icon(): SeamIcon | undefined | null;
+    set icon(value: SeamIcon | undefined | null);
+    _iconUrl: string | undefined | null;
+    _iconObj: IconProp | undefined | null;
+    private _iconUrlBeforeError;
+    private _iconObjBeforeError;
+    /**
+     * NOTE: Only works for fa-icon for now.
+     */
+    size: SizeProp | undefined | null;
+    /**
+     * Toggles whether an image that has thrown the `onerror` event should show
+     * the `defaultIcon` instead.
+     */
+    get showDefaultOnError(): boolean;
+    set showDefaultOnError(value: boolean);
+    private _showDefaultOnError;
+    /**
+     * Shown if icon is not set or if showDefaultOnError is true and img has thrown an error.
+     */
+    get defaultIcon(): SeamIcon | undefined | null;
+    set defaultIcon(value: SeamIcon | undefined | null);
+    _defaultIconUrl: string | undefined | null;
+    _defaultIconObj: IconProp | undefined | null;
+    iconType: TheSeamIconType | undefined | null;
+    get _iconTypeAttr(): TheSeamIconType | null;
+    private _hasError;
+    _imgError(event: ErrorEvent): void;
+    get _cssDisabled(): true | null;
+    get _cssNoGreyscale(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "seam-icon", never, { "grayscaleOnDisable": { "alias": "grayscaleOnDisable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "size": { "alias": "size"; "required": false; }; "showDefaultOnError": { "alias": "showDefaultOnError"; "required": false; }; "defaultIcon": { "alias": "defaultIcon"; "required": false; }; "iconType": { "alias": "iconType"; "required": false; }; }, {}, never, [".sr-only,seam-icon-notification"], false, never>;
+}
+
+declare class IconBtnComponent implements DoCheck {
+    private _elementRef;
+    private _renderer;
+    static ngAcceptInputType_grayscaleOnDisable: BooleanInput;
+    static ngAcceptInputType_disabled: BooleanInput;
+    static ngAcceptInputType_showDefaultOnError: BooleanInput;
+    /** Toggles whether the img/icon will attempt to be grayscale when disabled is true. */
+    grayscaleOnDisable: boolean;
+    /** Toggles the img/icon to grayscale if `grayscaleOnDisable` is true. */
+    disabled: boolean;
+    /**
+     * Placed on the `.seam-icon--fa` and `seam-icon--img` elements.
+     */
+    iconClass: string | undefined | null;
+    /**
+     * The icon to display.
+     *
+     * If the input icon is a string an `img` element will be used with icon as `src`.
+     * If the input is not a string it will be assumed to be a font-awesome IconProp object.
+     */
+    icon: SeamIcon | undefined | null;
+    /**
+     * NOTE: Only works for fa-icon for now.
+     */
+    size: SizeProp | undefined | null;
+    /**
+     * Toggles whether an image that has thrown the `onerror` event should show
+     * the `defaultIcon` instead.
+     */
+    showDefaultOnError: boolean;
+    /**
+     * Shown if icon is not set or if showDefaultOnError is true and img has thrown an error.
+     *
+     * NOTE: Not supported for icon-btn yet.
+     */
+    iconType: TheSeamIconType | undefined | null;
+    _cssPadding0: boolean;
+    _btn: boolean;
+    _textNoWrap: boolean;
+    get _btnDefault(): boolean;
+    get _btnPrimary(): boolean;
+    get _btnSecondary(): boolean;
+    get _btnSuccess(): boolean;
+    get _btnDanger(): boolean;
+    get _btnWarning(): boolean;
+    get _btnInfo(): boolean;
+    get _btnLight(): boolean;
+    get _btnDark(): boolean;
+    get _btnLightGray(): boolean;
+    get _btnSizeSm(): boolean;
+    get _btnSizeLg(): boolean;
+    btnTheme: ThemeTypes | undefined | null;
+    badgeTheme: ThemeTypes | undefined | null;
+    badgeText: string | undefined | null;
+    btnSize: 'sm' | 'lg' | undefined | null;
+    get type(): string | undefined | null;
+    set type(value: string | undefined | null);
+    private _type;
+    get role(): string | undefined | null;
+    set role(value: string | undefined | null);
+    private _role;
+    constructor(_elementRef: ElementRef<HTMLButtonElement | HTMLAnchorElement>, _renderer: Renderer2);
+    ngDoCheck(): void;
+    isBtnTheme(type: ThemeTypes): boolean;
+    protected _isButton(): boolean;
+    protected _isAnchor(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconBtnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconBtnComponent, "button[seamIconBtn]", never, { "grayscaleOnDisable": { "alias": "grayscaleOnDisable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "size": { "alias": "size"; "required": false; }; "showDefaultOnError": { "alias": "showDefaultOnError"; "required": false; }; "iconType": { "alias": "iconType"; "required": false; }; "btnTheme": { "alias": "btnTheme"; "required": false; }; "badgeTheme": { "alias": "badgeTheme"; "required": false; }; "badgeText": { "alias": "badgeText"; "required": false; }; "btnSize": { "alias": "btnSize"; "required": false; }; "type": { "alias": "type"; "required": false; }; "role": { "alias": "role"; "required": false; }; }, {}, never, [".sr-only,seam-icon-notification"], false, never>;
+}
+
+declare const pulseAnimation: _angular_animations.AnimationReferenceMetadata;
+declare class IconNotificationComponent implements OnInit {
+    private _elementRef;
+    static ngAcceptInputType_hidden: BooleanInput;
+    static ngAcceptInputType_grayscaleOnDisable: BooleanInput;
+    static ngAcceptInputType_disabled: BooleanInput;
+    static ngAcceptInputType_showDefaultOnError: BooleanInput;
+    count: number | undefined | null;
+    hidden: boolean;
+    /** Toggles whether the img/icon will attempt to be grayscale when disabled is true. */
+    grayscaleOnDisable: boolean;
+    /** Toggles the img/icon to grayscale if `grayscaleOnDisable` is true. */
+    disabled: boolean;
+    /**
+     * Placed on the `.seam-icon--fa` and `seam-icon--img` elements.
+     */
+    iconClass: string | undefined | null;
+    /**
+     * The icon to display.
+     *
+     * If the input icon is a string an `img` element will be used with icon as `src`.
+     * If the input is not a string it will be assumed to be a font-awesome IconProp object.
+     */
+    icon: SeamIcon | undefined | null;
+    /**
+     * Toggles whether an image that has thrown the `onerror` event should show
+     * the `defaultIcon` instead.
+     */
+    showDefaultOnError: boolean;
+    /**
+     * Shown if icon is not set or if showDefaultOnError is true and img has thrown an error.
+     *
+     * NOTE: Not supported for icon-notification yet.
+     */
+    /**
+     * NOTE: Only works for fa-icon for now.
+     */
+    size: SizeProp | undefined | null;
+    iconType: TheSeamIconType | undefined | null;
+    constructor(_elementRef: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconNotificationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconNotificationComponent, "seam-icon-notification", never, { "count": { "alias": "count"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; "grayscaleOnDisable": { "alias": "grayscaleOnDisable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "showDefaultOnError": { "alias": "showDefaultOnError"; "required": false; }; "size": { "alias": "size"; "required": false; }; "iconType": { "alias": "iconType"; "required": false; }; }, {}, never, [".sr-only"], false, never>;
+}
+
+declare class TheSeamIconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamIconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamIconModule, [typeof IconComponent, typeof IconBtnComponent, typeof IconNotificationComponent], [typeof i4.CommonModule, typeof i5.FontAwesomeModule], [typeof IconComponent, typeof IconBtnComponent, typeof IconNotificationComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamIconModule>;
+}
+
+declare const DEFAULT_FILE_EXTENSION_ICON: SeamIcon;
+declare function fileExtensionIcon(extension: string | null | undefined, defaultIfNotFound?: boolean): SeamIcon | undefined;
+
+declare function getKnownIcon(iconStr: string): SeamIcon | undefined;
+
+export { DEFAULT_FILE_EXTENSION_ICON, IconBtnComponent, IconComponent, IconNotificationComponent, TheSeamIconModule, fileExtensionIcon, getKnownIcon, pulseAnimation };
+export type { SeamIcon, TheSeamIconType };

package/index.d.ts

@@ -1,5 +1,2 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common" />
-export * from './public_api';
+
+export { };

package/layout/index.d.ts

@@ -1,5 +1,61 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/layout" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+import * as i2 from '@angular/flex-layout';
+import { MediaObserver } from '@angular/flex-layout';
+import { Observable } from 'rxjs';
+
+/**
+ * | breakpoint | mediaQuery                                              |
+ * |------------|---------------------------------------------------------|
+ * | xs         | 'screen and (max-width: 599px)'                         |
+ * | sm         | 'screen and (min-width: 600px) and (max-width: 959px)'  |
+ * | md         | 'screen and (min-width: 960px) and (max-width: 1279px)' |
+ * | lg         | 'screen and (min-width: 1280px) and (max-width: 1919px)'|
+ * | xl         | 'screen and (min-width: 1920px) and (max-width: 5000px)'|
+ * |            |                                                         |
+ * | lt-sm      | 'screen and (max-width: 599px)'                         |
+ * | lt-md      | 'screen and (max-width: 959px)'                         |
+ * | lt-lg      | 'screen and (max-width: 1279px)'                        |
+ * | lt-xl      | 'screen and (max-width: 1919px)'                        |
+ * |            |                                                         |
+ * | gt-xs      | 'screen and (min-width: 600px)'                         |
+ * | gt-sm      | 'screen and (min-width: 960px)'                         |
+ * | gt-md      | 'screen and (min-width: 1280px)'                        |
+ * | gt-lg      | 'screen and (min-width: 1920px)'                        |
+ */
+type MediaQueryAliases = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'lt-sm' | 'lt-md' | 'lt-lg' | 'lt-xl' | 'gt-xs' | 'gt-sm' | 'gt-md' | 'gt-lg';
+
+declare class TheSeamLayoutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamLayoutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamLayoutModule, never, [typeof i1.CommonModule, typeof i2.FlexLayoutModule], [typeof i2.FlexLayoutModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamLayoutModule>;
+}
+
+declare class TheSeamLayoutService {
+    private _media;
+    /**
+     * Observes if app is a mobile-like size.
+     * Default mobile breakpoint is <= 599px,
+     * use setMobileBreakpoint() to change size.
+     */
+    isMobile$: Observable<boolean>;
+    private _mobileBreakpoint;
+    mobileBreakpoint$: Observable<MediaQueryAliases>;
+    constructor(_media: MediaObserver);
+    observe(alias: MediaQueryAliases): Observable<boolean>;
+    /**
+     * Update breakpoint observed by isMobile$
+     */
+    setMobileBreakpoint(alias: MediaQueryAliases): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamLayoutService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TheSeamLayoutService>;
+}
+
+/**
+ * Observable helper for observing a single breakpoint alias with
+ * `@angular/flex-layout` MediaObserver.
+ */
+declare function observeMediaQuery(mediaObserver: MediaObserver, alias: MediaQueryAliases): Observable<boolean>;
+
+export { TheSeamLayoutModule, TheSeamLayoutService, observeMediaQuery };
+export type { MediaQueryAliases };

package/loading/index.d.ts

@@ -1,5 +1,42 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/loading" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { EnvironmentProviders } from '@angular/core';
+import { NgxLoadingConfig, INgxLoadingConfig } from 'ngx-loading';
+import * as i2 from '@angular/cdk/overlay';
+import * as i3 from '@angular/cdk/portal';
+import { Observable } from 'rxjs';
+
+type TheSeamLoadingTheme = 'default' | 'primary';
+
+declare class TheSeamLoadingComponent {
+    set theme(value: TheSeamLoadingTheme);
+    _theme: NgxLoadingConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamLoadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamLoadingComponent, "seam-loading", never, { "theme": { "alias": "theme"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TheSeamLoadingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamLoadingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamLoadingModule, never, [typeof TheSeamLoadingComponent], [typeof i2.OverlayModule, typeof i3.PortalModule, typeof TheSeamLoadingComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamLoadingModule>;
+}
+
+declare class TheSeamLoadingOverlayService {
+    private readonly _overlay;
+    private _enabled;
+    private _overlayRef?;
+    get enabled(): boolean;
+    toggle(enabled?: boolean): void;
+    enable(): void;
+    disable(): void;
+    while<T = any>(source: Observable<T>): Observable<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamLoadingOverlayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TheSeamLoadingOverlayService>;
+}
+
+declare const defaultThemeConfig: NgxLoadingConfig;
+declare const primaryThemeConfig: NgxLoadingConfig;
+
+declare function provideTheSeamLoading(loadingConfig?: INgxLoadingConfig): EnvironmentProviders;
+
+export { TheSeamLoadingComponent, TheSeamLoadingModule, TheSeamLoadingOverlayService, defaultThemeConfig, primaryThemeConfig, provideTheSeamLoading };
+export type { TheSeamLoadingTheme };