@theseam/ui-common 1.0.1 → 1.0.2-beta.15

package/footer-bar/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-footer-bar.mjs"
+}

package/form-field/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-form-field.mjs"
+}

package/form-field-error/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-form-field-error.mjs"
+}

package/framework/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-framework.mjs"
+}

package/google-maps/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-google-maps.mjs"
+}

package/graphql/index.d.ts

@@ -1,19 +1,65 @@
+import { ApolloLink, ApolloQueryResult, DocumentNode as DocumentNode$2, TypedDocumentNode, Operation as Operation$1 } from '@apollo/client/core';
 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 { DocumentNode as DocumentNode$1, ValueNode as ValueNode$1, OperationDefinitionNode, VariableDefinitionNode, VariableNode, ArgumentNode, FieldNode, Token as Token$1, GraphQLFormattedError } from 'graphql';
+import { Operation } 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 { InjectionToken, EventEmitter, Provider } from '@angular/core';
 import { OperationVariables } from '@apollo/client/core/types';
 import * as _theseam_ui_common_graphql from '@theseam/ui-common/graphql';
 
+interface LogQueryLinkOptions {
+    beforeStyles?: string;
+    afterStyles?: string;
+}
+/**
+ * Wraps an Apollo link and logs the operation state immediately before and
+ * after the wrapped link processes it.
+ *
+ * Useful for inspecting what `queryProcessingLink` does to a query:
+ *
+ * ```ts
+ * link: concat(
+ *   logQueryLink(queryProcessingLink),
+ *   httpLink,
+ * )
+ * ```
+ *
+ * The output uses `console.log` with optional CSS styles so each snapshot
+ * is easy to distinguish in the browser console. Tree-shaking will remove
+ * this from production builds when it is not imported.
+ */
+declare function logQueryLink(inner: ApolloLink, options?: LogQueryLinkOptions): ApolloLink;
+
+/**
+ * Apollo link that transforms GraphQL operations before they are sent.
+ *
+ * Two mechanisms are supported and can be combined freely:
+ *
+ * **Hint-based** — place `# @gql-hint: <name>` comments directly in the query.
+ * Supported hints:
+ * - `remove-not-defined` on the operation definition: removes every variable
+ *   whose value is null/undefined (definition + argument usage).
+ * - `inline-variable` on a variable definition or usage: substitutes the
+ *   variable's current value directly into the query AST and removes it from
+ *   the variables map.
+ *
+ * **Config-based** — pass a `QueryProcessingConfig` via Apollo context under
+ * the key `queryProcessingConfig`. Supported options:
+ * - `variables.removeIfNotDefined`: remove named variables when null/undefined.
+ * - `variables.removeIfNotUsed`: remove named variable definitions when the
+ *   variable is not referenced anywhere in the (possibly already-transformed)
+ *   query body.
+ * - `variables.inline`: inline named variables into the query AST.
+ *
+ * Hints are applied first, then config-based processing.
+ */
+declare const queryProcessingLink: ApolloLink;
+
 declare function containsVariable(node: DocumentNode | ValueNode, variableName: string): boolean;
 
 declare function gqlVar(varName: string): {
@@ -78,7 +124,7 @@ declare class GQLVariable {
     constructor(name: string, type: string);
 }
 
-type GqlDatatableAccessor = Pick<DatatableComponent, 'page' | 'sort' | 'sorts' | 'filterStates'> & {
+type GqlDatatableAccessor = Pick<DatatableComponent, 'page' | 'sort' | 'sorts' | 'filterStates' | 'resize' | 'pageInfo' | 'externalSorting'> & {
     ngxDatatable: {
         offset: number;
         pageSize: number;
@@ -129,20 +175,36 @@ type DatatableGraphQLVariables = {
     skip?: number;
     take?: number;
 } & EmptyObject;
+type DatatableGraphQLErrorHandler = (error: readonly GraphQLFormattedError[]) => void;
 /**
- * Partially wraps ApolloClient's QueryRef with some of our datatable boilerplate.
- *
- * TODO: Decide how to handle/display errors.
+ * Maximum number of error recovery attempts before throwing.
+ */
+declare const MAX_ERROR_RECOVERY_ATTEMPTS = 10;
+/**
+ * Partially wraps ApolloClient's QueryRef with datatable paging, loading
+ * state, error handling, and debounced variable updates.
  */
 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.
+     * How long to wait (ms) before applying variable changes and refetching.
      */
     private readonly _updatesPollDelay;
+    /**
+     * Default error handler used when no subscriber is listening to `error$`.
+     */
+    private readonly _defaultErrorHandler?;
     private readonly _variablesSubject;
     private readonly _observingChangesSubject;
+    private readonly _errorSubject;
+    /**
+     * Used to manually trigger a pending/loading state when we know a request is
+     * coming but Apollo hasn't started it yet (e.g. after setVariables resolves to
+     * a non-paging variable change while a request is already in-flight).
+     */
+    private readonly _manualPendingSubject;
+    private readonly _needToRequerySubject;
     /**
      * Temporary way of tracking total count when paging is disabled.
      */
@@ -152,17 +214,41 @@ declare class DatatableGraphQLQueryRef<TData, TVariables extends DatatableGraphQ
     private _variablesUpdatePending;
     private readonly _valueChanges;
     readonly loading$: Observable<boolean>;
+    /**
+     * Emits whenever the query variables change.
+     */
+    readonly variables$: Observable<TVariables>;
+    /**
+     * Emits when a GraphQL error occurs.
+     *
+     * If nothing is subscribed to this, the `_defaultErrorHandler` is used
+     * (if provided). Once subscribed, the subscriber is responsible for
+     * handling the error.
+     */
+    readonly error$: Observable<readonly GraphQLFormattedError[]>;
     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.
+     * How long to wait (ms) before applying variable changes and refetching.
      */
-    _updatesPollDelay?: number);
+    _updatesPollDelay?: number, 
+    /**
+     * Default error handler used when no subscriber is listening to `error$`.
+     */
+    _defaultErrorHandler?: DatatableGraphQLErrorHandler | undefined);
     rows(mapper: DatatableGraphQLDataMapper<TData, TRow>): Observable<TRow[]>;
     private _rowsObservable;
+    /**
+     * Reads the result and returns it unchanged if no errors.
+     *
+     * On errors: emits them via `error$` and replaces any `null` data properties
+     * with an empty collection shape `{ items: [], totalCount: 0 }` so mapper
+     * functions can run safely without special-casing the error path.
+     */
+    private _handleResult;
     private _needsToRequeryWithAllRecords;
     private _resolveRowMapper;
     getVariables(): TVariables;
@@ -170,11 +256,19 @@ declare class DatatableGraphQLQueryRef<TData, TVariables extends DatatableGraphQ
     private _patchVariablesImmediate;
     setVariables(variables: TVariables): void;
     patchVariables(variables: Partial<TVariables>): void;
-    refetch(variables?: TVariables): Promise<ApolloQueryResult<TData>>;
+    refetch(variables?: TVariables, showLoading?: boolean): Promise<ApolloQueryResult<TData>>;
     setQuery(query: DocumentNode$2 | TypedDocumentNode<TData, TVariables>, triggerRefetch?: boolean): void;
     getOptions(): WatchQueryOptions<TVariables, TData> | undefined;
     getQueryProcessingConfig(): QueryProcessingConfig | undefined;
+    /**
+     * Returns the variables that were actually sent with the last request, read
+     * directly from Apollo's observable query. This is more accurate than
+     * `_variablesSubject.value` when variables can change between the debounce
+     * firing and the response arriving.
+     */
+    private _getVariablesFromQueryRef;
     private _withVariableOverrides;
+    private _emitError;
 }
 
 type MapperContext<TExtraVariables = EmptyObject> = {
@@ -187,12 +281,54 @@ interface FilterStateMapperVariables {
     [name: string]: any;
 }
 interface FilterStateMapperFilter {
+    and?: FilterStateMapperFilter[];
+    or?: FilterStateMapperFilter[];
     [name: string]: any;
 }
 type FilterStateMapperResult = {
     filter: FilterStateMapperFilter;
     variables: FilterStateMapperVariables;
 } | null;
+/**
+ * A filter input type constrained to the field names of `T`.
+ *
+ * Use this as the building block for {@link TypedFilterStateMapperResult}
+ * when you want compile-time checking that filter conditions only reference
+ * real fields in the corresponding GQL input type.
+ *
+ * @example
+ * type MyFilter = TypedFilterInput<'id' | 'name'>
+ * // { id?: any; name?: any }
+ */
+type TypedFilterInput<T extends string | number | symbol> = {
+    [name in T]?: any;
+};
+/**
+ * A type-safe alternative to {@link FilterStateMapperResult} that constrains
+ * filter field names to the union `T`.
+ *
+ * The filter can be either a direct field-condition object or a combined
+ * object with `or`/`and` arrays:
+ *
+ * ```ts
+ * // Direct field condition
+ * { filter: { status: { eq: 'active' } }, variables: {} }
+ *
+ * // Combined (OR)
+ * { filter: { or: [{ id: { lt: 30 } }, { name: { contains: 'foo' } }] }, variables: {} }
+ * ```
+ *
+ * Because TypeScript uses structural typing, a mapper that returns
+ * `TypedFilterStateMapperResult<'id' | 'name'>` is assignable to the
+ * untyped {@link FilterStateMapper} signature without any cast.
+ */
+type TypedFilterStateMapperResult<T extends string | number | symbol> = {
+    filter: {
+        or?: TypedFilterInput<T>[];
+        and?: TypedFilterInput<T>[];
+    } | TypedFilterInput<T>;
+    variables: FilterStateMapperVariables;
+} | null;
 type FilterStateMapper = (filterState: DataFilterState, context: MapperContext) => FilterStateMapperResult | Promise<FilterStateMapperResult> | Observable<FilterStateMapperResult>;
 interface FilterStateMappers {
     [filterName: string]: FilterStateMapper;
@@ -205,6 +341,56 @@ type SortsMapperResult = {
 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[]>;
 
+/**
+ * A field mapping entry for {@link createSortsMapper}:
+ *
+ * - `string`   – the GQL sort-field name to emit for this column
+ * - `null`     – column is not sortable; the sort item will be dropped
+ * - `function` – `(prop, context) => string | null` for dynamic mapping
+ *                with access to {@link MapperContext}
+ */
+type SortsMapperFieldEntry = string | null | ((prop: string, context: MapperContext) => string | null);
+/**
+ * A map from every column prop name in `TColumns` to its GQL sort field.
+ *
+ * Requiring every key at compile time provides exhaustiveness checking
+ * without needing a switch statement.
+ */
+type SortsMapperFieldMap<TColumns extends string> = {
+    [K in TColumns]: SortsMapperFieldEntry;
+};
+/**
+ * Creates a {@link SortsMapper} from a declarative field-name map.
+ *
+ * Each key must correspond to a datatable column `prop` value. The value
+ * controls how that column's sort is translated to a GQL sort object:
+ *
+ * - `string`   – emits `{ [gqlField]: 'ASC' | 'DESC' }`
+ * - `null`     – column is not sortable; the sort item is dropped
+ * - `function` – called with `(prop, context)` and may return a field
+ *                name or `null` to drop the item dynamically
+ *
+ * In dev mode an error is thrown when a sort item's `prop` is not present
+ * in the map. In production the item is silently dropped.
+ *
+ * @example
+ * // Simple static mapping
+ * const mapSorts = createSortsMapper<'id' | 'name'>({
+ *   id: 'id',
+ *   name: 'name',
+ * })
+ *
+ * @example
+ * // Dynamic mapping with context access
+ * const mapSorts = createSortsMapper<'id' | 'name' | 'computed'>({
+ *   id: 'id',
+ *   name: 'name',
+ *   computed: (prop, context) =>
+ *     context.extraVariables.useAlt ? 'altField' : prop,
+ * })
+ */
+declare function createSortsMapper<TColumns extends string>(fieldMap: SortsMapperFieldMap<TColumns>): SortsMapper;
+
 /**
  * NOTE: Any of ApolloClient's WatchQueryOptions properties can be set, but I
  * think our components should only be providing `query` and `variables`. The
@@ -237,8 +423,22 @@ declare const mapSearchNumericColumnsDataFilterStateToGql: (filterState: Columns
 
 declare const mapSearchTextColumnsDataFilterStateToGql: (filterState: ColumnsDataFilterState<TheSeamColumnsDataFilterTextSearchFormState>, context: MapperContext<any>) => FilterStateMapperResult;
 
+/**
+ * Inlines the variable's current value directly into the query AST and removes
+ * the variable definition from the parameter list. The variable is also
+ * removed from the operation's variables map so it is not sent to the server.
+ *
+ * Applies to VariableDefinition (comment above the `$var` in the parameter
+ * list) or Variable (inline comment beside a `$var` usage in the query body).
+ */
 declare const inlineVariableTransformer: HintTransformer;
 
+/**
+ * Removes every variable from the query that is null or undefined in the
+ * operation's variables map. Both the variable definition (from the parameter
+ * list) and any argument usages in the query body are removed so the resulting
+ * document remains valid.
+ */
 declare const removeNotDefinedTransformer: HintTransformer;
 
 /**
@@ -254,23 +454,43 @@ declare const removeNotDefinedHintDef: HintDefinition;
 
 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;
+type WhereArg = Record<string, any>;
+/**
+ * Filters an array using a HotChocolate-style where clause.
+ *
+ * Top-level field conditions are implicitly ANDed. Use `and`/`or` arrays for
+ * explicit logical grouping.
+ *
+ * @example
+ * filterWhere(records, { name: { contains: 'foo' }, id: { gt: 5 } })
+ * filterWhere(records, { or: [{ name: { eq: 'a' } }, { name: { eq: 'b' } }] })
+ */
 declare function filterWhere<T>(data: T[], where: WhereArg): T[];
 
 declare function skipAndTake<T>(data: T[], skip: number, take: number): T[];
 
+/**
+ * A single sort clause in HotChocolate's order format.
+ * Each object has exactly one key: the field name, with a value of 'ASC' or 'DESC'.
+ *
+ * @example { memberOrganizationName: 'ASC' }
+ */
+type SortClause = Record<string, 'ASC' | 'DESC'>;
+/**
+ * Sorts an array by a HotChocolate-style `order` argument.
+ *
+ * Earlier entries in the array take higher sort precedence. When two records
+ * are equal on all sort clauses they retain their original relative order
+ * (stable sort).
+ *
+ * Handles strings (locale-aware), numbers/dates, booleans, and null/undefined
+ * values (nulls sort last for both ASC and DESC).
+ *
+ * @example
+ * sortItems(records, [{ name: 'ASC' }, { id: 'DESC' }])
+ */
+declare function sortItems<T>(items: T[], order: SortClause[]): T[];
+
 interface FilteredResultsPageInfo {
     hasNextPage: boolean;
     hasPreviousPage: boolean;
@@ -291,9 +511,12 @@ declare class MockDatatable implements GqlDatatableAccessor {
     private _bodyHeight;
     private _scrolledPosV;
     page: EventEmitter<TheSeamPageInfo>;
+    resize: EventEmitter<any>;
+    externalSorting: boolean;
     sort: EventEmitter<SortEvent>;
     get sorts(): SortItem[];
     set sorts(value: SortItem[]);
+    get pageInfo(): TheSeamPageInfo;
     readonly filterStates: Observable<DataFilterState[]>;
     static pageDefaults(dt: any, defaultPageSize?: number): TheSeamPageInfo;
     get ngxDatatable(): {
@@ -323,56 +546,48 @@ declare class MockDatatable implements GqlDatatableAccessor {
 
 declare function checkRecordsHaveValue(arr: any[] | null, indices: (number | [startIndex: number, endIndex: number])[], testValueCheckProp?: string | null, onlyCheckProvidedIndices?: boolean): void;
 
+interface MockGraphQLLinkOptions {
+    resolve: (operation: Operation$1) => any;
+    delay?: number;
+}
+declare function mockGraphQLLink(options: MockGraphQLLinkOptions): ApolloLink;
+
+interface MockApolloTestingProviderOptions {
+    resolve: (operation: Operation) => any;
+    delay?: number;
+}
 /**
- * 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.
+ * Creates Apollo providers configured like our apps, except with the Apollo
+ * HttpLink replaced with a mock link that delegates to a `resolve` callback.
+ * No GraphQL schema is required — the resolve function returns the response
+ * directly, typically using `filteredResults` for sorting/filtering/paging.
  */
-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;
-            };
-        };
-    };
-};
+declare function createMockApolloTestingProvider(options: MockApolloTestingProviderOptions): Provider;
 
 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>;
+/**
+ * Like {@link SIMPLE_GQL_TEST_QUERY} but includes `$search: String` for use
+ * with search filters that inline a `gqlVar('search')` reference via
+ * `queryProcessingConfig.variables.inline`.
+ */
+declare const SIMPLE_GQL_TEST_SEARCH_QUERY: apollo_angular.TypedDocumentNode<unknown, unknown>;
 interface SimpleGqlTestExtraVariables {
 }
 interface SimpleGqlTestVariables extends SimpleGqlTestExtraVariables {
     skip?: number;
     take?: number;
-    order?: any;
+    order?: Partial<Record<keyof SimpleGqlTestRecord, 'ASC' | 'DESC'>>[];
     where?: any;
+    search?: string;
 }
 
-export { DATATABLE_GRAPHQL_SERVICE_CONFIG, DEFAULT_PAGE_SIZE, DEFAULT_TO_REMOVE_ON_UNDEFINED, DatatableGraphQLQueryRef, DatatableGraphqlService, GQLDirection, GQLVariable, HINT_NAMES_CAPTURE_REGEX, HINT_PREFIX_REGEX, HintsKind, MockDatatable, SIMPLE_GQL_TEST_QUERY, baseSchemaFragment, checkRecordsHaveValue, containsVariable, createApolloTestingProvider, createHintsToken, createSimpleGqlTestRecord, createSimpleGqlTestRoot, filterWhere, filteredResults, getHintsToken, getPageInfo, getTokenAppliesTo, gqlVar, hintNamesFromHintToken, hintsTokensContainingHint, inlineVariable, inlineVariableHintDef, inlineVariableTransformer, isCommentToken, isHintToken, isInlineComment, mapFilterStates, mapSearchDateColumnsDataFilterStateToGql, mapSearchNumericColumnsDataFilterStateToGql, mapSearchTextColumnsDataFilterStateToGql, observeRowsWithGqlInputsHandling, parseAst, parseComments, parseHints, removeNotDefinedHintDef, removeNotDefinedTransformer, removeVariable, removeVariableDefinition, removeVariableDefinitionsNotDefined, simpleGqlTestSchema, skipAndTake, toGQL };
-export type { DatatableGraphQLDataMapper, DatatableGraphQLDataMapperResult, DatatableGraphQLVariables, DatatableGraphqlServiceConfig, DatatableQueryOptions, EmptyObject, FilterStateMapper, FilterStateMapperFilter, FilterStateMapperResult, FilterStateMapperVariables, FilterStateMappers, FilteredResults, FilteredResultsPageInfo, GqlDatatableAccessor, HintDefinition, HintTransformOperation, HintTransformer, HintsToken, MapperContext, QueryProcessingConfig, QueryProcessingVariablesConfig, SimpleGqlTestExtraVariables, SimpleGqlTestRecord, SimpleGqlTestVariables, SortsMapper, SortsMapperResult, WhereArg };
+export { DATATABLE_GRAPHQL_SERVICE_CONFIG, DEFAULT_PAGE_SIZE, DEFAULT_TO_REMOVE_ON_UNDEFINED, DatatableGraphQLQueryRef, DatatableGraphqlService, GQLDirection, GQLVariable, HINT_NAMES_CAPTURE_REGEX, HINT_PREFIX_REGEX, HintsKind, MAX_ERROR_RECOVERY_ATTEMPTS, MockDatatable, SIMPLE_GQL_TEST_QUERY, SIMPLE_GQL_TEST_SEARCH_QUERY, baseSchemaFragment, checkRecordsHaveValue, containsVariable, createHintsToken, createMockApolloTestingProvider, createSimpleGqlTestRecord, createSimpleGqlTestRoot, createSortsMapper, filterWhere, filteredResults, getHintsToken, getPageInfo, getTokenAppliesTo, gqlVar, hintNamesFromHintToken, hintsTokensContainingHint, inlineVariable, inlineVariableHintDef, inlineVariableTransformer, isCommentToken, isHintToken, isInlineComment, logQueryLink, mapFilterStates, mapSearchDateColumnsDataFilterStateToGql, mapSearchNumericColumnsDataFilterStateToGql, mapSearchTextColumnsDataFilterStateToGql, mockGraphQLLink, observeRowsWithGqlInputsHandling, parseAst, parseComments, parseHints, queryProcessingLink, removeNotDefinedHintDef, removeNotDefinedTransformer, removeVariable, removeVariableDefinition, removeVariableDefinitionsNotDefined, skipAndTake, sortItems, toGQL };
+export type { DatatableGraphQLDataMapper, DatatableGraphQLDataMapperResult, DatatableGraphQLErrorHandler, DatatableGraphQLVariables, DatatableGraphqlServiceConfig, DatatableQueryOptions, EmptyObject, FilterStateMapper, FilterStateMapperFilter, FilterStateMapperResult, FilterStateMapperVariables, FilterStateMappers, FilteredResults, FilteredResultsPageInfo, GqlDatatableAccessor, HintDefinition, HintTransformOperation, HintTransformer, HintsToken, LogQueryLinkOptions, MapperContext, MockApolloTestingProviderOptions, MockGraphQLLinkOptions, QueryProcessingConfig, QueryProcessingVariablesConfig, SimpleGqlTestExtraVariables, SimpleGqlTestRecord, SimpleGqlTestVariables, SortClause, SortsMapper, SortsMapperFieldEntry, SortsMapperFieldMap, SortsMapperResult, TypedFilterInput, TypedFilterStateMapperResult, WhereArg };

package/graphql/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-graphql.mjs"
+}

package/icon/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-icon.mjs"
+}

package/layout/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-layout.mjs"
+}

package/loading/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-loading.mjs"
+}

package/menu/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-menu.mjs"
+}

package/modal/README.md

@@ -1,5 +1,5 @@
-# Modal
-
-For now this module will be mostly using code from the `cdk-experimental` `dialog`.
-
-When `cdk-experimental` gets moved to `cdk` we may just end up using it. If we have neccessary customizations for our use cases then this will just wrap it or extend neccessary parts.
+# Modal
+
+For now this module will be mostly using code from the `cdk-experimental` `dialog`.
+
+When `cdk-experimental` gets moved to `cdk` we may just end up using it. If we have neccessary customizations for our use cases then this will just wrap it or extend neccessary parts.

package/modal/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-modal.mjs"
+}

package/models/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-models.mjs"
+}

package/navigation-reload/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-navigation-reload.mjs"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theseam/ui-common",
-  "version": "1.0.1",
+  "version": "1.0.2-beta.15",
   "peerDependencies": {
     "@angular/cdk": "^20.2.3",
     "@angular/common": "^20.3.0",
@@ -343,4 +343,4 @@
     }
   },
   "sideEffects": false
-}
+}

package/popover/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-popover.mjs"
+}

package/progress/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-progress.mjs"
+}

package/rich-text/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-rich-text.mjs"
+}

package/scrollbar/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-scrollbar.mjs"
+}

package/services/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-services.mjs"
+}

package/shared/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-shared.mjs"
+}

package/storage/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-storage.mjs"
+}

package/story-helpers/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-story-helpers.mjs"
+}

package/tabbed/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-tabbed.mjs"
+}

package/table/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-table.mjs"
+}

package/table-cell-type/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-table-cell-type.mjs"
+}

package/table-cell-types/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/theseam-ui-common-table-cell-types.mjs"
+}