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

package/styles/vendor/quill/_quill.scss

@@ -1,7 +1,7 @@
 @import 'quill/dist/quill.core';
 @import 'quill/dist/quill.bubble';
 @import 'quill/dist/quill.snow';
-@import 'quill-mention/dist/quill.mention';
+@import 'node_modules/quill-mention/dist/quill.mention';
 
 $quill-input-border-radius: $input-border-radius !default;
 
@@ -41,7 +41,7 @@ $quill-mention-padding: 3px !default;
 $quill-mention-denotation-margin: 0 0 2px 0 !default;
 
 quill-editor {
-  display: flex;
+  display: flex !important;
   flex-direction: column;
   @include border-top-radius($quill-input-border-radius);
   @include border-bottom-radius($quill-input-border-radius);

package/tabbed/index.d.ts

@@ -1,5 +1,108 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/tabbed" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { TemplateRef, OnInit, ElementRef, AfterContentInit, OnDestroy, QueryList, EventEmitter } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Router, ActivatedRoute } from '@angular/router';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+interface TheSeamTabbedTabAccessor {
+    isActive: boolean;
+}
+interface TheSeamTabbedTabContentAccessor {
+    isActive: boolean;
+}
+interface TheSeamTabbedItemAccessor {
+    tabbedTabTpl?: TemplateRef<TheSeamTabbedTabAccessor>;
+    tabbedContentTpl?: TemplateRef<TheSeamTabbedTabContentAccessor>;
+    contentFromRoute: boolean;
+}
+
+declare class TheSeamTabbedTabContentDirective implements TheSeamTabbedTabContentAccessor {
+    isActive: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTabbedTabContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamTabbedTabContentDirective, "[seamTabbedTabContent]", ["seamTabbedTabContent"], {}, {}, never, never, true, never>;
+}
+
+declare type TheSeamTabsDirection = 'horizontal' | 'vertical';
+declare class TheSeamTabbedService {
+    private _tabGroups;
+    registerTab(tab: TheSeamTabbedComponent, groupName: string): void;
+    unregisterTab(tab: TheSeamTabbedComponent, groupName: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTabbedService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TheSeamTabbedService>;
+}
+
+declare class TheSeamTabbedTabDirective implements OnInit, TheSeamTabbedTabAccessor {
+    elementRef: ElementRef;
+    tabbedService: TheSeamTabbedService;
+    isActive: boolean;
+    constructor(elementRef: ElementRef, tabbedService: TheSeamTabbedService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTabbedTabDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamTabbedTabDirective, "[seamTabbedTab]", ["seamTabbedTab"], {}, {}, never, never, true, never>;
+}
+
+declare class TheSeamTabbedItemComponent implements TheSeamTabbedItemAccessor {
+    static ngAcceptInputType_contentFromRoute: BooleanInput;
+    tabbedTabTpl?: TemplateRef<TheSeamTabbedTabDirective>;
+    tabbedContentTpl?: TemplateRef<TheSeamTabbedTabContentDirective>;
+    name: string | undefined | null;
+    label: string | undefined | null;
+    contentFromRoute: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTabbedItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamTabbedItemComponent, "seam-tabbed-item", never, { "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "contentFromRoute": { "alias": "contentFromRoute"; "required": false; }; }, {}, ["tabbedTabTpl", "tabbedContentTpl"], never, true, never>;
+}
+
+declare class TheSeamTabbedComponent implements OnInit, AfterContentInit, OnDestroy {
+    private readonly _tabbedService;
+    private readonly _router;
+    private readonly _route;
+    private _direction;
+    private _hideTabs;
+    set tabbedItems(val: QueryList<TheSeamTabbedItemComponent> | undefined);
+    get tabbedItems(): QueryList<TheSeamTabbedItemComponent> | undefined;
+    private readonly _tabbedItems;
+    readonly tabbedItems$: rxjs.Observable<QueryList<TheSeamTabbedItemComponent> | undefined>;
+    tabChanged: EventEmitter<TheSeamTabbedItemComponent>;
+    set direction(val: TheSeamTabsDirection);
+    get direction(): TheSeamTabsDirection;
+    set hideTabs(val: boolean);
+    get hideTabs(): boolean;
+    onlyRouteContent: boolean;
+    get selectedTab(): TheSeamTabbedItemComponent | undefined;
+    set selectedTab(tab: TheSeamTabbedItemComponent | undefined);
+    private readonly _selectedTab;
+    readonly selectedTab$: rxjs.Observable<TheSeamTabbedItemComponent | undefined>;
+    set activeTabName(val: string);
+    private readonly _activeTabName;
+    private readonly activeTabName$;
+    constructor(_tabbedService: TheSeamTabbedService, _router: Router, _route: ActivatedRoute);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterContentInit(): void;
+    /**
+     *
+     */
+    onClickTab(event: any, tab: TheSeamTabbedItemComponent): void;
+    /**
+     * TODO: Make more generic, so that the name isn't the only way
+     *  to select a tab
+     */
+    selectTab(name?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTabbedComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamTabbedComponent, "seam-tabbed", never, { "direction": { "alias": "direction"; "required": false; }; "hideTabs": { "alias": "hideTabs"; "required": false; }; "onlyRouteContent": { "alias": "onlyRouteContent"; "required": false; }; "activeTabName": { "alias": "activeTabName"; "required": false; }; }, { "tabChanged": "tabChanged"; }, ["tabbedItems"], never, true, never>;
+}
+
+declare class TheSeamTabbedContentComponent {
+    tabbedItem?: TheSeamTabbedItemAccessor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTabbedContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamTabbedContentComponent, "seam-tabbed-content", never, { "tabbedItem": { "alias": "tabbedItem"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TheSeamTabbedModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTabbedModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamTabbedModule, never, [typeof TheSeamTabbedComponent, typeof TheSeamTabbedTabContentDirective, typeof TheSeamTabbedTabDirective, typeof TheSeamTabbedItemComponent, typeof TheSeamTabbedContentComponent], [typeof TheSeamTabbedComponent, typeof TheSeamTabbedTabContentDirective, typeof TheSeamTabbedTabDirective, typeof TheSeamTabbedItemComponent, typeof TheSeamTabbedContentComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamTabbedModule>;
+}
+
+export { TheSeamTabbedComponent, TheSeamTabbedContentComponent, TheSeamTabbedItemComponent, TheSeamTabbedModule, TheSeamTabbedService, TheSeamTabbedTabContentDirective, TheSeamTabbedTabDirective };
+export type { TheSeamTabbedItemAccessor, TheSeamTabbedTabAccessor, TheSeamTabbedTabContentAccessor, TheSeamTabsDirection };

package/table/index.d.ts

@@ -1,5 +1,110 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/table" />
-export * from './public-api';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from '@angular/core';
+import { TemplateRef, OnChanges, SimpleChanges, OnInit, AfterContentChecked, EventEmitter, QueryList } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as rxjs from 'rxjs';
+import { TableColumnProp } from '@marklb/ngx-datatable';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/cdk/table';
+import * as i4 from '@theseam/ui-common/table-cell-type';
+
+declare class TheSeamTableCellTplDirective {
+    template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTableCellTplDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamTableCellTplDirective, "[seamTableCellTpl]", never, {}, {}, never, never, true, never>;
+}
+
+declare class TheSeamTableColumnComponent implements OnChanges {
+    name?: string | null;
+    prop?: TableColumnProp | null;
+    flexGrow?: number | null;
+    headerClass?: string | null;
+    cellClass?: string | null;
+    private _isFirstChange;
+    cellTplDirective?: TheSeamTableCellTplDirective;
+    _cellTemplateInput?: TemplateRef<any> | null;
+    _cellTemplateQuery?: TemplateRef<any>;
+    get cellTemplate(): TemplateRef<any> | undefined | null;
+    _headerTemplateInput?: TemplateRef<any> | null;
+    _headerTemplateQuery?: TemplateRef<any>;
+    get headerTemplate(): TemplateRef<any> | undefined | null;
+    private readonly _columnChange;
+    columnChange$: rxjs.Observable<void>;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTableColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TheSeamTableColumnComponent, "seam-table-column", never, { "name": { "alias": "name"; "required": false; }; "prop": { "alias": "prop"; "required": false; }; "flexGrow": { "alias": "flexGrow"; "required": false; }; "headerClass": { "alias": "headerClass"; "required": false; }; "cellClass": { "alias": "cellClass"; "required": false; }; "_cellTemplateInput": { "alias": "cellTemplate"; "required": false; }; "_headerTemplateInput": { "alias": "headerTemplate"; "required": false; }; }, {}, ["cellTplDirective", "_cellTemplateQuery", "_headerTemplateQuery"], never, true, never>;
+}
+
+/**
+ * An optional function passed into the `NgForOf` directive that defines how to track
+ * changes for items in an iterable.
+ * The function takes the iteration index and item ID.
+ * When supplied, Angular tracks changes by the return value of the function.
+ *
+ * NOTE: Can't import the type from'@angular/core', because of a bug in angular-cli's
+ * build that can't find exported types that only exist at compile time if there
+ * are exports that exist at runtime in the same file.
+ */
+type TrackByFunction<T> = (index: number, item: T) => any;
+interface ITableColumn {
+    prop: string;
+    name?: string;
+    cellTemplate?: TemplateRef<any>;
+    headerTemplate?: TemplateRef<any>;
+    cellClass?: string;
+    headerClass?: string;
+}
+declare class TableComponent<T = any> implements OnInit, OnChanges, AfterContentChecked {
+    private readonly _sanitizer;
+    static ngAcceptInputType_hasHeader: BooleanInput;
+    private readonly _ngUnsubscribe;
+    get columns(): (string | ITableColumn)[] | undefined | null;
+    set columns(value: (string | ITableColumn)[] | undefined | null);
+    private _columns;
+    get rows(): T[] | undefined | null;
+    set rows(value: T[] | undefined | null);
+    private _rows;
+    get displayedRows(): T[] & {
+        _colSpan?: number;
+    };
+    private _displayedRows;
+    trackBy: TrackByFunction<T> | undefined | null;
+    size: 'sm' | 'md' | undefined | null;
+    hasHeader: boolean;
+    private _pendingColumns?;
+    displayedRecords?: ITableColumn[];
+    displayedColumns?: string[];
+    readonly columnsChange: EventEmitter<{
+        previous: ITableColumn[] | undefined;
+        current: ITableColumn[];
+    }>;
+    readonly actionRefreshRequest: EventEmitter<void>;
+    set columnComponents(value: QueryList<TheSeamTableColumnComponent> | undefined);
+    private _columnComponents;
+    private _columnComponentChange;
+    constructor(_sanitizer: DomSanitizer);
+    ngOnInit(): void;
+    ngAfterContentChecked(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _updateColumns;
+    private _setColumns;
+    triggerActionRefreshRequest(): void;
+    _trackByRecords(r: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "seam-table", never, { "columns": { "alias": "columns"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; "size": { "alias": "size"; "required": false; }; "hasHeader": { "alias": "hasHeader"; "required": false; }; }, { "columnsChange": "columnsChange"; "actionRefreshRequest": "actionRefreshRequest"; }, ["columnComponents"], never, false, never>;
+}
+
+declare class TheSeamTableColumnHeaderTplDirective {
+    template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTableColumnHeaderTplDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamTableColumnHeaderTplDirective, "[seamTableColumnHeaderTpl]", never, {}, {}, never, never, true, never>;
+}
+
+declare class TheSeamTableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamTableModule, [typeof TableComponent], [typeof i2.CommonModule, typeof i3.CdkTableModule, typeof i4.TheSeamTableCellTypeModule, typeof TheSeamTableColumnComponent, typeof TheSeamTableCellTplDirective, typeof TheSeamTableColumnHeaderTplDirective], [typeof TableComponent, typeof TheSeamTableColumnComponent, typeof TheSeamTableCellTplDirective, typeof TheSeamTableColumnHeaderTplDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamTableModule>;
+}
+
+export { TableComponent, TheSeamTableCellTplDirective, TheSeamTableColumnComponent, TheSeamTableColumnHeaderTplDirective, TheSeamTableModule };
+export type { ITableColumn, TrackByFunction };

package/table-cell-type/index.d.ts

@@ -1,5 +1,145 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/table-cell-type" />
-export * from './public-api';
+import { DynamicActionConfirmDef, DynamicValue, DynamicActionHelperService, DynamicValueHelperService, DynamicActionModalDef } from '@theseam/ui-common/dynamic';
+import * as i3 from '@angular/cdk/portal';
+import { ComponentType, ComponentPortal } from '@angular/cdk/portal';
+import * as i0 from '@angular/core';
+import { SimpleChanges, InjectionToken, AfterViewInit, OnChanges, Injector, ChangeDetectorRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { TableColumn } from '@marklb/ngx-datatable';
+import * as i2 from '@angular/common';
+
+type TableCellTypeName = string;
+
+interface TableCellActionBase<T extends TableCellTypeName> {
+    type: T;
+    /**
+     * If defined, the action must be confirmed.
+     */
+    confirmDef?: DynamicActionConfirmDef;
+    /**
+     * Default: false
+     */
+    disabled?: boolean;
+}
+
+interface TableCellTypeConfig<T extends TableCellTypeName> {
+    type: T;
+    /**
+     * Styles added to the root cell elements `style` attribute.
+     */
+    styles?: string | string[];
+    /**
+     * Classes added to the root cell elements `class` attribute.
+     */
+    cssClass?: string | string[];
+}
+
+interface TableCellTypeColumn<T extends TableCellTypeName, C extends TableCellTypeConfig<T>> {
+    /**
+     * If undefined the value will be rendered as a string.
+     */
+    cellType?: T;
+    /**
+     * Config to pass to the cell component.
+     */
+    cellTypeConfig?: C;
+}
+
+interface TableCellTypeExportProps {
+    /**
+     * Ignore column in export.
+     */
+    exportIgnore?: boolean;
+    /**
+     * Column header in export.
+     */
+    exportHeader?: string;
+    /**
+     * Transform function for column value in export.
+     */
+    exportValue?: DynamicValue<string>;
+}
+
+interface ITableCellTypeManifest {
+    /**
+     * Name used to reference the cell type. Must be unique to avoid incorrect cell selection.
+     */
+    name: string;
+    /**
+     * The cell type component.
+     *
+     * TODO: Add support for lazy loaded cells. This isn't important yet, but
+     * later on we may have many unused cell types or a large cell type that isn't
+     * used often.
+     */
+    component: ComponentType<unknown>;
+}
+interface ICalucatedValueContext<R = any, V = any> extends Partial<TableCellData<any, any, R, V>> {
+    [key: string]: any;
+}
+type CalculatedValueContextFn = () => ICalucatedValueContext;
+type CaluclatedValueContextType = ICalucatedValueContext | CalculatedValueContextFn;
+type TheSeamTableColumn<T extends TableCellTypeName, C extends TableCellTypeConfig<T> = any> = TableColumn & TableCellTypeColumn<T, C> & TableCellTypeExportProps;
+interface TableCellDataChange<T extends TableCellTypeName, C extends TableCellTypeConfig<T>> {
+    data: TableCellData<T, C>;
+    changes: SimpleChanges;
+}
+interface TableCellData<T extends TableCellTypeName, C extends TableCellTypeConfig<T>, R = any, V = any> {
+    row: R;
+    rowIndex: number;
+    colData: TheSeamTableColumn<T, C>;
+    value: V;
+    changed: Observable<TableCellDataChange<T, C>>;
+}
+
+declare const TABLE_CELL_TYPE_MANIFEST: InjectionToken<ITableCellTypeManifest>;
+declare const TABLE_CELL_DATA: InjectionToken<TableCellData<any, any, any, any>>;
+
+interface ITableCellTypeManifestProvider {
+    provide: typeof TABLE_CELL_TYPE_MANIFEST;
+    useValue: ITableCellTypeManifest;
+    multi: true;
+}
+
+declare class TableCellTypeSelectorComponent<T extends string = any, D = any, V = any> implements AfterViewInit, OnChanges {
+    private _injector;
+    private _ref;
+    type: T | undefined | null;
+    value: V | undefined | null;
+    rowIndex: number | undefined | null;
+    row: D | undefined | null;
+    colData: TheSeamTableColumn<T, TableCellTypeConfig<T>> | undefined | null;
+    componentPortal?: ComponentPortal<unknown>;
+    private _data;
+    private _dataChangeSubject?;
+    private _manifests;
+    constructor(_injector: Injector, _ref: ChangeDetectorRef, manifests?: ITableCellTypeManifest[]);
+    ngAfterViewInit(): void;
+    private _getComponent;
+    private _createInjector;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _tryUpdateDataProp;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellTypeSelectorComponent<any, any, any>, [null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableCellTypeSelectorComponent<any, any, any>, "seam-table-cell-type-selector", never, { "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; "rowIndex": { "alias": "rowIndex"; "required": false; }; "row": { "alias": "row"; "required": false; }; "colData": { "alias": "colData"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TableCellTypesHelpersService {
+    private _dynamicActionHelper;
+    private _valueHelper;
+    constructor(_dynamicActionHelper: DynamicActionHelperService, _valueHelper: DynamicValueHelperService);
+    parseValueProp(value: any, contextOrContextFn: CaluclatedValueContextType): any;
+    getValueContext<T extends TableCellTypeName>(value: any, data?: TableCellData<T, TableCellTypeConfig<T>>): ICalucatedValueContext;
+    private _resolveValueContext;
+    handleModalAction<R = any>(action: DynamicActionModalDef, contextOrContextFn: CaluclatedValueContextType): Observable<R>;
+    private _handleModalAction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellTypesHelpersService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableCellTypesHelpersService>;
+}
+
+declare class TheSeamTableCellTypeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamTableCellTypeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamTableCellTypeModule, [typeof TableCellTypeSelectorComponent], [typeof i2.CommonModule, typeof i3.PortalModule], [typeof TableCellTypeSelectorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamTableCellTypeModule>;
+}
+
+export { TABLE_CELL_DATA, TABLE_CELL_TYPE_MANIFEST, TableCellTypeSelectorComponent, TableCellTypesHelpersService, TheSeamTableCellTypeModule };
+export type { CalculatedValueContextFn, CaluclatedValueContextType, ICalucatedValueContext, ITableCellTypeManifest, ITableCellTypeManifestProvider, TableCellActionBase, TableCellData, TableCellDataChange, TableCellTypeColumn, TableCellTypeConfig, TableCellTypeExportProps, TableCellTypeName, TheSeamTableColumn };