@myrmidon/cadmus-ui 12.0.1 → 13.0.0

package/index.d.ts

@@ -1,5 +1,600 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, ElementRef, OnDestroy } from '@angular/core';
+import { FormGroup, UntypedFormGroup, FormArray, FormBuilder, UntypedFormControl, UntypedFormBuilder, FormControl, ValidatorFn, AbstractControl } from '@angular/forms';
+import { TokenLocation, TextLayerService, FacetDefinition, FlagDefinition, LayerHint, DataPinInfo, IndexLookupDefinitions, Thesaurus, PartTypeIds, ThesaurusEntry, Part, Fragment, ThesauriSet, TextLayerPart } from '@myrmidon/cadmus-core';
+import { DialogService } from '@myrmidon/ngx-mat-tools';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { ItemService, FacetService, UserService } from '@myrmidon/cadmus-api';
+import { NestedTreeControl } from '@angular/cdk/tree';
+import { MatTreeNestedDataSource } from '@angular/material/tree';
+import { AuthJwtService, User } from '@myrmidon/auth-jwt-login';
+import { AppRepository } from '@myrmidon/cadmus-state';
+import { RefLookupService, RefLookupFilter } from '@myrmidon/cadmus-refs-lookup';
+
+declare class CloseSaveButtonsComponent {
+    readonly form: _angular_core.InputSignal<FormGroup<any> | UntypedFormGroup | undefined>;
+    readonly noSave: _angular_core.InputSignal<boolean | undefined>;
+    readonly closeRequest: _angular_core.OutputEmitterRef<void>;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CloseSaveButtonsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CloseSaveButtonsComponent, "cadmus-close-save-buttons", never, { "form": { "alias": "form"; "required": false; "isSignal": true; }; "noSave": { "alias": "noSave"; "required": false; "isSignal": true; }; }, { "closeRequest": "closeRequest"; }, never, never, true, never>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Decorated token-based text visualizer. This is used when editing
+ * token-based text layers.
  */
-/// <amd-module name="@myrmidon/cadmus-ui" />
-export * from './public-api';
+declare class DecoratedTokenTextComponent implements OnInit {
+    private _textLayerService;
+    _textElement?: ElementRef;
+    /**
+     * The base text.
+     */
+    readonly baseText: _angular_core.InputSignal<string>;
+    /**
+     * The token-based locations of all the fragments in the layer.
+     */
+    readonly locations: _angular_core.InputSignal<TokenLocation[]>;
+    /**
+     * A selected token-based location.
+     */
+    readonly selectedLocation: _angular_core.InputSignal<TokenLocation | undefined>;
+    text?: string;
+    constructor(_textLayerService: TextLayerService);
+    ngOnInit(): void;
+    private decorate;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DecoratedTokenTextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DecoratedTokenTextComponent, "cadmus-decorated-token-text", never, { "baseText": { "alias": "baseText"; "required": false; "isSignal": true; }; "locations": { "alias": "locations"; "required": false; "isSignal": true; }; "selectedLocation": { "alias": "selectedLocation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ErrorListComponent {
+    readonly errors: _angular_core.InputSignal<string[] | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ErrorListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ErrorListComponent, "cadmus-error-list", never, { "errors": { "alias": "errors"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Colors helper service.
+ */
+declare class ColorService {
+    /**
+     * Get the R,G,B components of the color expressed by the specified
+     * RGB string (3 or 6 digits format).
+     *
+     * @param rgb The RGB color string (3 or 6 digits).
+     * @returns An array where [0]=R, [1]=G, [2]=B, or null if invalid
+     * input string.
+     */
+    getRgb(rgb: string): number[] | null;
+    /**
+     * Get black or white according to which of them has the maximum contrast
+     * against the specified color.
+     *
+     * @param rgb The RGB color string.
+     * @returns Black or white. If rgb is invalid, always black.
+     */
+    getContrastColor(rgb: string): string;
+    /**
+     * Convert HSL to RGB.
+     *
+     * @param h Hue
+     * @param s Saturation
+     * @param l Lightness
+     * @returns Object with r, g, b values.
+     */
+    hslToRgb(h: number, s: number, l: number): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    rgbToString(r: number, g: number, b: number): string;
+    /**
+     * Get the next color from a palette generated to include
+     * the specified count of colors.
+     *
+     * @param index The index of the next color in the palette.
+     * @param count The total count of colors in the palette.
+     * @param blueBoost True to adjust colors for the eye's lack of sensitivity to blue.
+     * @returns The RRGGBB values string.
+     */
+    nextPaletteColor(index: number, count: number, blueBoost?: boolean): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ColorService>;
+}
+
+interface FacetBadgeData {
+    definitions: FacetDefinition[];
+    facetId?: string;
+}
+declare class FacetBadgeComponent {
+    private _colorService;
+    private _facetColors;
+    private _facetTips;
+    color: string;
+    contrastColor: string;
+    tip?: string;
+    /**
+     * The facet data.
+     */
+    readonly data: _angular_core.InputSignal<FacetBadgeData>;
+    constructor(_colorService: ColorService);
+    private getFacetColor;
+    private getFacetTip;
+    private updateBadge;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FacetBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FacetBadgeComponent, "cadmus-facet-badge", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Data for FlagsBadgeComponent, including flags and their definitions.
+ */
+interface FlagsBadgeData {
+    definitions: FlagDefinition[];
+    flags: number;
+}
+/**
+ * Badge with item's flags. Each flag is represented by a circle filled
+ * with the flag's color key.
+ */
+declare class FlagsBadgeComponent {
+    badgeFlags: FlagDefinition[];
+    readonly data: _angular_core.InputSignal<FlagsBadgeData | undefined>;
+    constructor();
+    private updateBadge;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlagsBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlagsBadgeComponent, "cadmus-flags-badge", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class LayerHintsComponent {
+    private _formBuilder;
+    private _dialogService;
+    readonly hints: _angular_core.InputSignal<LayerHint[]>;
+    readonly targetLocation: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignal<boolean | undefined>;
+    readonly readonly: _angular_core.InputSignal<boolean | undefined>;
+    readonly requestEdit: _angular_core.OutputEmitterRef<LayerHint>;
+    readonly requestDelete: _angular_core.OutputEmitterRef<LayerHint>;
+    readonly requestMove: _angular_core.OutputEmitterRef<LayerHint>;
+    readonly requestPatch: _angular_core.OutputEmitterRef<string[]>;
+    form: FormGroup;
+    checks: FormArray;
+    constructor(_formBuilder: FormBuilder, _dialogService: DialogService);
+    private updateChecks;
+    emitRequestEdit(hint: LayerHint): void;
+    emitRequestDelete(hint: LayerHint): void;
+    emitRequestMove(hint: LayerHint): void;
+    emitRequestPatch(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LayerHintsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LayerHintsComponent, "cadmus-layer-hints", never, { "hints": { "alias": "hints"; "required": false; "isSignal": true; }; "targetLocation": { "alias": "targetLocation"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "requestEdit": "requestEdit"; "requestDelete": "requestDelete"; "requestMove": "requestMove"; "requestPatch": "requestPatch"; }, never, never, true, never>;
+}
+
+/**
+ * Generic data pin lookup component. This allows users typing a part
+ * of a pin's value, and get the full pin. For instance, if you have
+ * a lookup set of colors and type "gr", you might get the pins
+ * corresponding to "green" (e.g. id=color, value=green), "gray", etc.
+ * Usage: add a FormControl to hold a DataPinInfo value; in the HTML
+ * template set the component's lookupKey, label, initialValue, and
+ * entryChange handler. The initialValue, if any, should be the initial
+ * DataPinInfo value.
+ * If you are using this component as a pure lookup device, don't set
+ * the initialValue and set resetOnPick=true.
+ */
+declare class LookupPinComponent implements OnInit {
+    private _itemService;
+    private _lookupDefs;
+    /**
+     * The entry value initially set when the component loads.
+     */
+    readonly initialValue: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The label to be displayed for this lookup.
+     */
+    readonly label: _angular_core.InputSignal<string>;
+    /**
+     * The maximum count of lookup entries to retrieve.
+     * Default is 10.
+     */
+    readonly limit: _angular_core.InputSignal<number>;
+    /**
+     * True to reset the lookup value after it is picked.
+     * This is typically used when you use this component
+     * as a pure lookup device, storing the picked value
+     * elsewhere when handling its entryChange event.
+     */
+    readonly resetOnPick: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Fired whenever an entry is picked. Usually you should
+     * cast the received argument to a more specific type.
+     */
+    readonly entryChange: _angular_core.OutputEmitterRef<DataPinInfo | null>;
+    form: UntypedFormGroup;
+    lookup: UntypedFormControl;
+    entries$: Observable<DataPinInfo[]> | undefined;
+    entry: DataPinInfo | undefined;
+    constructor(formBuilder: UntypedFormBuilder, _itemService: ItemService, _lookupDefs: IndexLookupDefinitions);
+    /**
+     * The lookup key to be used for this component.
+     * This should be a key from the injectable indexLookupDefinitions.
+     */
+    readonly lookupKey: _angular_core.InputSignal<string | undefined>;
+    ngOnInit(): void;
+    private lookupEntries;
+    private resetToInitial;
+    clear(): void;
+    entryToName(entry: DataPinInfo): string;
+    pickEntry(entry: DataPinInfo): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LookupPinComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LookupPinComponent, "cadmus-lookup-pin", never, { "initialValue": { "alias": "initialValue"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "limit": { "alias": "limit"; "required": false; "isSignal": true; }; "resetOnPick": { "alias": "resetOnPick"; "required": false; "isSignal": true; }; "lookupKey": { "alias": "lookupKey"; "required": false; "isSignal": true; }; }, { "entryChange": "entryChange"; }, never, never, true, never>;
+}
+
+declare enum PartBadgeType {
+    partAndRole = 0,
+    partOnly = 1,
+    roleOnly = 2
+}
+/**
+ * Function used to get the part's human-friendly name from its ID and role ID.
+ * This assumes that thesaurus entries with role ID specified have form
+ * partId:roleId.
+ * @param typeId The part type ID.
+ * @param roleId The optional role ID.
+ * @param typeThesaurus The types thesaurus.
+ * @param noFallback If true, and no thesaurus is provided, return undefined
+ * rather than the type and role IDs.
+ * @returns The name.
+ */
+declare function getPartIdName(typeId: string, roleId?: string | null, typeThesaurus?: Thesaurus, noFallback?: boolean): string | undefined;
+/**
+ * Part badge component. This component displays a badge with the
+ * part's type name and role name, if any, and a background color.
+ */
+declare class PartBadgeComponent {
+    private _facetService;
+    private _colorService;
+    typeName: string | undefined;
+    roleName: string | undefined;
+    color: string;
+    contrastColor: string;
+    /**
+     * The badge type: 0=part and role, 1=part only, 2=role only.
+     */
+    readonly badgeType: _angular_core.InputSignal<PartBadgeType>;
+    /**
+     * The types thesaurus.
+     */
+    readonly typeThesaurus: _angular_core.InputSignal<Thesaurus | undefined>;
+    /**
+     * The part's facet definition.
+     */
+    readonly facetDefinition: _angular_core.InputSignal<FacetDefinition | undefined>;
+    /**
+     * The part type IDs.
+     */
+    readonly partTypeIds: _angular_core.InputSignal<PartTypeIds | undefined>;
+    constructor(_facetService: FacetService, _colorService: ColorService);
+    private getPartColor;
+    /**
+     * Get the role's human-friendly name from its ID.
+     * @param roleId The role ID.
+     * @param typeThesaurus The types thesaurus.
+     * @returns The name.?
+     */
+    private getRoleIdName;
+    private updateBadge;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PartBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PartBadgeComponent, "cadmus-part-badge", never, { "badgeType": { "alias": "badgeType"; "required": false; "isSignal": true; }; "typeThesaurus": { "alias": "typeThesaurus"; "required": false; "isSignal": true; }; "facetDefinition": { "alias": "facetDefinition"; "required": false; "isSignal": true; }; "partTypeIds": { "alias": "partTypeIds"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface TreeNode {
+    id: string;
+    label: string;
+    originalLabel?: string;
+    parent?: TreeNode;
+    children?: TreeNode[];
+    clickable?: boolean;
+}
+/**
+ * A label rendering function which removes from a label
+ * all the characters past the last colon, trimming the result.
+ * This is a typical rendering when dealing with hierarchical
+ * thesaurus entries, e.g. "furniture: table: color", where
+ * we can shorten the label to just "color", as "furniture"
+ * and "table" are its ancestors.
+ */
+declare const renderLabelFromLastColon: (label: string) => string;
+/**
+ * Thesaurus tree component.
+ * This component displays a set of hierarchical thesaurus entries
+ * in a tree, provided that each entry marks its hierarchy with
+ * dots. For instance, say you have the hierarchy "furniture" -
+ * "type" - "color". You might have an entry whose ID is
+ * "furniture.table.red", with a sibling "furniture.table.green",
+ * and a parent "furniture.table". This parent is there only to
+ * provide a label to the parent node, but only leaf nodes can be
+ * picked by the user. Whenever one is picked, the entryChange
+ * event is emitted. Note that even if you specify a label renderer
+ * function, the event always emits the original label.
+ */
+declare class ThesaurusTreeComponent implements OnInit {
+    /**
+     * The thesaurus entries.
+     */
+    readonly entries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * The label for the root node.
+     */
+    readonly rootLabel: _angular_core.InputSignal<string>;
+    /**
+     * The optional node label rendering function.
+     */
+    readonly renderLabel: _angular_core.InputSignal<((label: string) => string) | undefined>;
+    /**
+     * Fired when a thesaurus entry is selected.
+     */
+    readonly entryChange: _angular_core.OutputEmitterRef<ThesaurusEntry>;
+    root: TreeNode;
+    treeControl: NestedTreeControl<TreeNode>;
+    treeDataSource: MatTreeNestedDataSource<TreeNode>;
+    filter: FormControl<string | null>;
+    form: FormGroup;
+    foundNodes: TreeNode[] | undefined;
+    hasChildren: (index: number, node: TreeNode) => boolean | undefined;
+    isRoot: (index: number, node: TreeNode) => boolean;
+    constructor(formBuilder: FormBuilder);
+    ngOnInit(): void;
+    private initTree;
+    private getLabel;
+    private addNode;
+    /**
+     * Build a tree model from a list of name=value pairs,
+     * where each value can include one or more components separated by
+     * the specified separator.
+     * @param entries The entries to add.
+     * @param separator string The separator string to use for values.
+     */
+    buildTreeModel(entries: ThesaurusEntry[], separator?: string): TreeNode;
+    onTreeNodeClick(node: TreeNode): void;
+    expandAll(): void;
+    collapseAll(): void;
+    private expandFromNode;
+    private expandMatchingNodes;
+    find(): void;
+    resetFilter(): void;
+    isFoundNode(node: TreeNode): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThesaurusTreeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThesaurusTreeComponent, "cadmus-thesaurus-tree", never, { "entries": { "alias": "entries"; "required": false; "isSignal": true; }; "rootLabel": { "alias": "rootLabel"; "required": false; "isSignal": true; }; "renderLabel": { "alias": "renderLabel"; "required": false; "isSignal": true; }; }, { "entryChange": "entryChange"; }, never, never, true, never>;
+}
+
+/**
+ * The identifiers for an edited part.
+ */
+interface PartIdentity {
+    itemId: string;
+    typeId: string;
+    partId: string | null;
+    roleId: string | null;
+}
+/**
+ * The identifiers for an edited fragment.
+ */
+interface FragmentIdentity extends PartIdentity {
+    frTypeId: string;
+    frRoleId: string | null;
+    loc: string;
+}
+/**
+ * An edited part or fragment.
+ */
+interface EditedObject<T extends Part | Fragment> {
+    value: T | null;
+    thesauri: ThesauriSet;
+    layerPart?: TextLayerPart;
+    baseText?: string;
+}
+/**
+ * Base class for part/fragment editors dumb components.
+ * The model type is the templated argument T.
+ *
+ * When deriving from this editor, be sure to call super.ngOnInit()
+ * from the derived editor's ngOnInit handler.
+ */
+declare abstract class ModelEditorComponentBase<T extends Part | Fragment> implements OnInit, OnDestroy {
+    protected authService: AuthJwtService;
+    protected formBuilder: FormBuilder;
+    private readonly _mebSubs;
+    protected readonly _appRepository?: AppRepository;
+    /**
+     * The root form of the editor.
+     */
+    form: FormGroup | UntypedFormGroup;
+    /**
+     * The current user.
+     */
+    user?: User;
+    /**
+     * The user authorization level (0-4).
+     */
+    userLevel: number;
+    /**
+     * An observable with the current dirty state of the editor.
+     */
+    isDirty$: BehaviorSubject<boolean>;
+    /**
+     * The identity of the edited model.
+     */
+    readonly identity: _angular_core.InputSignal<PartIdentity | FragmentIdentity | undefined>;
+    /**
+     * The data being edited.
+     */
+    readonly data: _angular_core.ModelSignal<EditedObject<T> | undefined>;
+    /**
+     * True to disable the editor.
+     */
+    readonly disabled: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Event emitted when the dirty state has changed.
+     * This event just reflects changes in isDirty$, and is a facility
+     * for propagating it to the parent's component.
+     */
+    readonly dirtyChange: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * Emitted when the user requests to close the editor.
+     */
+    readonly editorClose: _angular_core.OutputEmitterRef<void>;
+    /**
+     * The human-friendly model name. This is computed from the model's
+     * type ID and role ID, if any, using the types thesaurus set provided
+     * by the app repository.
+     */
+    readonly modelName: _angular_core.Signal<string | undefined>;
+    /**
+     * Create a new instance of the editor.
+     *
+     * @param authService The authentication service.
+     * @param formBuilder Form builder.
+     */
+    constructor(authService: AuthJwtService, formBuilder: FormBuilder);
+    private disableForm;
+    private onIdentitySet;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Implement in the derived class to build the root form of this editor.
+     * The form built will then be attached to the dirty check mechanism
+     * provided by this base class.
+     *
+     * @param formBuilder The form builder.
+     */
+    protected abstract buildForm(formBuilder: FormBuilder): FormGroup | UntypedFormGroup;
+    /**
+     * Get the authorization level of the current user if any.
+     * @returns 4-1 for admin, editor, operator, visitor; else 0.
+     */
+    private getCurrentUserLevel;
+    private updateUserProperties;
+    /**
+     * Update the data value property and emit the corresponding
+     * modelChange event.
+     *
+     * @param value The value.
+     */
+    protected updateValue(value: T): void;
+    /**
+     * Invoked whenever the model property is set (=data comes from input model
+     * property), unless setting it via updateModel. Implement to update the form
+     * controls to reflect the new model data.
+     *
+     * @param data The data set, or undefined.
+     */
+    protected abstract onDataSet(data?: EditedObject<T>): void;
+    /**
+     * Get a new object from the edited part if any, else as a new part.
+     *
+     * @param typeId The part's type ID. This is a constant received
+     * from the implementor.
+     * @returns Part object.
+     */
+    protected getEditedPart(typeId: string): Part;
+    /**
+     * Get a new object from the edited fragment if any, else a new fragment.
+     *
+     * @returns Fragment object.
+     */
+    protected getEditedFragment(): Fragment;
+    /**
+     * Implement in derived classes to get the data from form's controls.
+     * This is used when saving.
+     */
+    protected abstract getValue(): T;
+    /**
+     * True if this editor has the thesaurus having the specified key in the
+     * loaded thesauri set.
+     */
+    protected hasThesaurus(key: string): boolean;
+    /**
+     * Emit a request to close the editor.
+     */
+    close(): void;
+    /**
+     * Save the edited data if valid.
+     */
+    save(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModelEditorComponentBase<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModelEditorComponentBase<any>, "ng-component", never, { "identity": { "alias": "identity"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "data": "dataChange"; "dirtyChange": "dirtyChange"; "editorClose": "editorClose"; }, never, never, false, never>;
+}
+
+/**
+ * General-purpose custom validators.
+ */
+declare class CustomValidators {
+    /**
+     * Validates a FormGroup or FormArray control checking if the count of their
+     * controls with a true value is equal to or greater than the specified
+     * number.
+     *
+     * @param min The minimum number of checked controls.
+     */
+    static minChecked(min?: number): ValidatorFn;
+}
+
+/**
+ * Simple JSON validator.
+ */
+declare class JsonValidators {
+    static json(control: AbstractControl): {
+        [key: string]: boolean;
+    } | null;
+}
+
+interface UserWithRoles {
+    user: {
+        id: string;
+        firstName: string;
+        lastName: string;
+        userName: string;
+        email: string;
+    };
+    roles: string[];
+}
+/**
+ * Service for users lookup.
+ */
+declare class UserRefLookupService implements RefLookupService {
+    private _userService;
+    constructor(_userService: UserService);
+    lookup(filter: RefLookupFilter, options?: any): Observable<UserWithRoles[]>;
+    getName(item: UserWithRoles): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserRefLookupService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UserRefLookupService>;
+}
+
+/**
+ * Extract arguments of function
+ */
+type ArgumentsType<F> = F extends (...args: infer A) => any ? A : never;
+/**
+ * Creates an object like O. Optionally provide minimum set of properties P
+ * which the objects must share to conform.
+ */
+type ObjectLike<O extends object, P extends keyof O = keyof O> = Pick<O, P>;
+/**
+ * Extract a touched changed observable from an abstract control.
+ * Use in component code like:
+ * this.touchedChanges$ = extractTouchedChanges(this.form);
+ *
+ * @param control AbstractControl-like object with markAsTouched method.
+ */
+declare const extractTouchedChanges: (control: ObjectLike<AbstractControl, "markAsTouched" | "markAsUntouched">) => Observable<boolean>;
+/**
+ * Extract a pristine changed observable from an abstract control.
+ * Use in component code like:
+ * this.pristineChanges$ = extractPristineChanges(this.form);
+ *
+ * @param control AbstractControl-like object with markAsPristine and markAsDirty
+ * methods.
+ */
+declare const extractPristineChanges: (control: ObjectLike<AbstractControl, "markAsPristine" | "markAsDirty">) => Observable<boolean>;
+
+export { CloseSaveButtonsComponent, ColorService, CustomValidators, DecoratedTokenTextComponent, ErrorListComponent, FacetBadgeComponent, FlagsBadgeComponent, JsonValidators, LayerHintsComponent, LookupPinComponent, ModelEditorComponentBase, PartBadgeComponent, PartBadgeType, ThesaurusTreeComponent, UserRefLookupService, extractPristineChanges, extractTouchedChanges, getPartIdName, renderLabelFromLastColon };
+export type { ArgumentsType, EditedObject, FacetBadgeData, FlagsBadgeData, FragmentIdentity, PartIdentity, UserWithRoles };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myrmidon/cadmus-ui",
-  "version": "12.0.1",
+  "version": "13.0.0",
   "description": "Cadmus - general UI components.",
   "keywords": [
     "Cadmus"
@@ -14,11 +14,11 @@
     "name": "Daniele Fusi"
   },
   "peerDependencies": {
-    "@angular/common": "^19.0.0",
-    "@angular/core": "^19.0.0",
-    "@myrmidon/ngx-tools": "^1.0.2",
-    "@myrmidon/cadmus-refs-lookup": "^8.0.1",
-    "@myrmidon/cadmus-core": "^11.0.0"
+    "@angular/common": "^20.0.0",
+    "@angular/core": "^20.0.0",
+    "@myrmidon/ngx-tools": "^2.0.0",
+    "@myrmidon/cadmus-refs-lookup": "^9.0.0",
+    "@myrmidon/cadmus-core": "^12.0.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"

package/lib/components/close-save-buttons/close-save-buttons.component.d.ts

@@ -1,10 +0,0 @@
-import { FormGroup, UntypedFormGroup } from '@angular/forms';
-import * as i0 from "@angular/core";
-export declare class CloseSaveButtonsComponent {
-    readonly form: import("@angular/core").InputSignal<FormGroup<any> | UntypedFormGroup | undefined>;
-    readonly noSave: import("@angular/core").InputSignal<boolean | undefined>;
-    readonly closeRequest: import("@angular/core").OutputEmitterRef<void>;
-    close(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CloseSaveButtonsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CloseSaveButtonsComponent, "cadmus-close-save-buttons", never, { "form": { "alias": "form"; "required": false; "isSignal": true; }; "noSave": { "alias": "noSave"; "required": false; "isSignal": true; }; }, { "closeRequest": "closeRequest"; }, never, never, true, never>;
-}

package/lib/components/decorated-token-text/decorated-token-text.component.d.ts

@@ -1,29 +0,0 @@
-import { OnInit, ElementRef } from '@angular/core';
-import { TokenLocation, TextLayerService } from '@myrmidon/cadmus-core';
-import * as i0 from "@angular/core";
-/**
- * Decorated token-based text visualizer. This is used when editing
- * token-based text layers.
- */
-export declare class DecoratedTokenTextComponent implements OnInit {
-    private _textLayerService;
-    _textElement?: ElementRef;
-    /**
-     * The base text.
-     */
-    readonly baseText: import("@angular/core").InputSignal<string>;
-    /**
-     * The token-based locations of all the fragments in the layer.
-     */
-    readonly locations: import("@angular/core").InputSignal<TokenLocation[]>;
-    /**
-     * A selected token-based location.
-     */
-    readonly selectedLocation: import("@angular/core").InputSignal<TokenLocation | undefined>;
-    text?: string;
-    constructor(_textLayerService: TextLayerService);
-    ngOnInit(): void;
-    private decorate;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DecoratedTokenTextComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DecoratedTokenTextComponent, "cadmus-decorated-token-text", never, { "baseText": { "alias": "baseText"; "required": false; "isSignal": true; }; "locations": { "alias": "locations"; "required": false; "isSignal": true; }; "selectedLocation": { "alias": "selectedLocation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/lib/components/error-list/error-list.component.d.ts

@@ -1,6 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class ErrorListComponent {
-    readonly errors: import("@angular/core").InputSignal<string[] | undefined>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorListComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorListComponent, "cadmus-error-list", never, { "errors": { "alias": "errors"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}