@myrmidon/cadmus-refs-asserted-ids 9.0.0 → 10.0.0

package/index.d.ts

@@ -1,5 +1,496 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy } from '@angular/core';
+import { FormControl, FormGroup, FormBuilder } from '@angular/forms';
+import { IndexLookupDefinitions, ThesaurusEntry, DataPinInfo, Item, Part, IndexLookupDefinition } from '@myrmidon/cadmus-core';
+import { Assertion } from '@myrmidon/cadmus-refs-assertion';
+import { Observable } from 'rxjs';
+import { ItemService, ThesaurusService } from '@myrmidon/cadmus-api';
+import { RefLookupService, RefLookupFilter, RefLookupConfig, RefLookupSetEvent } from '@myrmidon/cadmus-refs-lookup';
+import { DialogService } from '@myrmidon/ngx-mat-tools';
+import { RamStorageService } from '@myrmidon/ngx-tools';
+import { MatSnackBar } from '@angular/material/snack-bar';
+
 /**
- * Generated bundle index. Do not edit.
+ * Pin-based lookup filter. This is a RefLookupFilter with the addition
+ * of the item ID and part ID, which are used to filter the results
+ * by the ItemPinLookupComponent.
  */
-/// <amd-module name="@myrmidon/cadmus-refs-asserted-ids" />
-export * from './public-api';
+interface PinRefLookupFilter extends RefLookupFilter {
+    itemId?: string;
+    partId?: string;
+}
+/**
+ * Cadmus pin-based lookup data service. The text being searched here is just
+ * the pin's value, according to the options specified. These options correspond
+ * to an index lookup definition. The resulting items are of type DataPinInfo.
+ */
+declare class PinRefLookupService implements RefLookupService {
+    private _itemService;
+    constructor(_itemService: ItemService);
+    getName(item: any | undefined): string;
+    private buildQuery;
+    lookup(filter: PinRefLookupFilter, options?: any): Observable<any[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PinRefLookupService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PinRefLookupService>;
+}
+
+/**
+ * An asserted ID.
+ */
+interface AssertedId {
+    tag?: string;
+    value: string;
+    label?: string;
+    scope: string;
+    assertion?: Assertion;
+}
+/**
+ * Asserted ID editor component.
+ */
+declare class AssertedIdComponent implements OnInit, OnDestroy {
+    lookupService: PinRefLookupService;
+    lookupDefs: IndexLookupDefinitions;
+    private _sub?;
+    private _updatingForm;
+    tag: FormControl<string | null>;
+    value: FormControl<string | null>;
+    label: FormControl<string | null>;
+    scope: FormControl<string | null>;
+    assertion: FormControl<Assertion | null>;
+    form: FormGroup;
+    lookupExpanded: boolean;
+    readonly idScopeEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly idTagEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly assTagEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly refTypeEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly refTagEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * The asserted ID being edited.
+     */
+    readonly id: _angular_core.ModelSignal<AssertedId | undefined>;
+    /**
+     * True to hide the pin-based EID lookup UI.
+     */
+    readonly noEidLookup: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * True to show the submit button.
+     */
+    readonly hasSubmit: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Emitted when the editor is closed.
+     */
+    readonly editorClose: _angular_core.OutputEmitterRef<void>;
+    constructor(formBuilder: FormBuilder, lookupService: PinRefLookupService, lookupDefs: IndexLookupDefinitions);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onAssertionChange(assertion: Assertion | undefined): void;
+    onIdPick(id: string): void;
+    private updateForm;
+    private getId;
+    emitIdChange(): void;
+    cancel(): void;
+    save(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AssertedIdComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AssertedIdComponent, "cadmus-refs-asserted-id", never, { "idScopeEntries": { "alias": "idScopeEntries"; "required": false; "isSignal": true; }; "idTagEntries": { "alias": "idTagEntries"; "required": false; "isSignal": true; }; "assTagEntries": { "alias": "assTagEntries"; "required": false; "isSignal": true; }; "refTypeEntries": { "alias": "refTypeEntries"; "required": false; "isSignal": true; }; "refTagEntries": { "alias": "refTagEntries"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "noEidLookup": { "alias": "noEidLookup"; "required": false; "isSignal": true; }; "hasSubmit": { "alias": "hasSubmit"; "required": false; "isSignal": true; }; }, { "id": "idChange"; "editorClose": "editorClose"; }, never, never, true, never>;
+}
+
+/**
+ * Asserted IDs editor.
+ */
+declare class AssertedIdsComponent {
+    private _dialogService;
+    private _editedIndex;
+    edited?: AssertedId;
+    /**
+     * The asserted IDs.
+     */
+    readonly ids: _angular_core.ModelSignal<AssertedId[]>;
+    readonly idScopeEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly idTagEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly assTagEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly refTypeEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly refTagEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    entries: FormControl<AssertedId[]>;
+    form: FormGroup;
+    constructor(formBuilder: FormBuilder, _dialogService: DialogService);
+    private updateForm;
+    addId(): void;
+    editId(id: AssertedId, index: number): void;
+    closeId(): void;
+    saveId(entry: AssertedId): void;
+    deleteId(index: number): void;
+    moveIdUp(index: number): void;
+    moveIdDown(index: number): void;
+    onIdChange(id?: AssertedId): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AssertedIdsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AssertedIdsComponent, "cadmus-refs-asserted-ids", never, { "ids": { "alias": "ids"; "required": false; "isSignal": true; }; "idScopeEntries": { "alias": "idScopeEntries"; "required": false; "isSignal": true; }; "idTagEntries": { "alias": "idTagEntries"; "required": false; "isSignal": true; }; "assTagEntries": { "alias": "assTagEntries"; "required": false; "isSignal": true; }; "refTypeEntries": { "alias": "refTypeEntries"; "required": false; "isSignal": true; }; "refTagEntries": { "alias": "refTagEntries"; "required": false; "isSignal": true; }; }, { "ids": "idsChange"; }, never, never, true, never>;
+}
+
+interface MetadataPart$1 extends Part {
+    metadata: {
+        type?: string;
+        name: string;
+        value: string;
+    }[];
+}
+interface LookupInfo {
+    pin: DataPinInfo;
+    item?: Item;
+    part?: MetadataPart$1;
+}
+declare class ScopedPinLookupComponent {
+    private _itemService;
+    lookupService: PinRefLookupService;
+    lookupDefs: IndexLookupDefinitions;
+    key: FormControl<string | null>;
+    keyForm: FormGroup;
+    keys: string[];
+    info?: LookupInfo;
+    id: FormControl<string | null>;
+    idForm: FormGroup;
+    /**
+     * Emitted whenever the user picks an ID.
+     */
+    readonly idPick: _angular_core.OutputEmitterRef<string>;
+    constructor(formBuilder: FormBuilder, _itemService: ItemService, lookupService: PinRefLookupService, lookupDefs: IndexLookupDefinitions);
+    ngOnInit(): void;
+    onItemChange(item: unknown): void;
+    appendIdComponent(type: string, metaIndex?: number): void;
+    pickId(): void;
+    resetId(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScopedPinLookupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScopedPinLookupComponent, "cadmus-scoped-pin-lookup", never, {}, { "idPick": "idPick"; }, never, never, true, never>;
+}
+
+declare class ItemRefLookupService implements RefLookupService {
+    private _itemService;
+    constructor(_itemService: ItemService);
+    lookup(filter: RefLookupFilter, options?: any): Observable<Item[]>;
+    getName(item: Item): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItemRefLookupService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ItemRefLookupService>;
+}
+
+interface MetadataPart extends Part {
+    metadata: {
+        type?: string;
+        name: string;
+        value: string;
+    }[];
+}
+/**
+ * Pin lookup data used internally by the component.
+ */
+interface PinLookupData {
+    pin: DataPinInfo;
+    item?: Item;
+    metaPart?: MetadataPart;
+}
+/**
+ * A pin-based target. This includes pin's name and value, and
+ * the item's ID and optional part IDs. The label is a user friendly
+ * string representation of the target, while the gid is a globally
+ * unique identifier for the target.
+ */
+interface PinTarget {
+    gid: string;
+    label: string;
+    itemId?: string;
+    partId?: string;
+    partTypeId?: string;
+    roleId?: string;
+    name?: string;
+    value?: string;
+}
+declare class PinTargetLookupComponent implements OnInit, OnDestroy {
+    private _presetLookupDefs;
+    itemLookupService: ItemRefLookupService;
+    pinLookupService: PinRefLookupService;
+    private _itemService;
+    private _thesService;
+    private _snackbar;
+    private readonly _subs;
+    private _noTargetUpdate?;
+    private _noFormUpdate?;
+    private _startWithByTypeMode?;
+    /**
+     * True when the by-type pin lookup mode is active.
+     * User can change mode unless modeSwitching is false.
+     */
+    readonly pinByTypeMode: _angular_core.ModelSignal<boolean | undefined>;
+    /**
+     * True when the user can switch between by-type and by-item mode.
+     */
+    readonly canSwitchMode: _angular_core.ModelSignal<boolean | undefined>;
+    /**
+     * True when the user can edit the target's gid/label for internal
+     * targets.
+     */
+    readonly canEditTarget: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * The lookup definitions to be used for the by-type lookup. If
+     * not specified, the lookup definitions will be got via injection
+     * when available; if the injected definitions are empty, the
+     * lookup definitions will be built from the model-types thesaurus;
+     * if this is not available either, the by-type lookup will be
+     * disabled.
+     */
+    readonly lookupDefinitions: _angular_core.ModelSignal<IndexLookupDefinitions | undefined>;
+    /**
+     * The optional configurations for using external lookup services.
+     */
+    readonly extLookupConfigs: _angular_core.InputSignal<RefLookupConfig[]>;
+    /**
+     * True if when a new target is set it should be internal rather than
+     * external by default.
+     */
+    readonly internalDefault: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * The target to be edited.
+     */
+    readonly target: _angular_core.ModelSignal<PinTarget | undefined>;
+    /**
+     * The default value for part type key when the by-type mode is active.
+     */
+    readonly defaultPartTypeKey: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Emitted when user closes the editor.
+     */
+    readonly editorClose: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emitted when the user requests more items from an external lookup.
+     */
+    readonly extMoreRequest: _angular_core.OutputEmitterRef<RefLookupSetEvent>;
+    /**
+     * Emitted when the user changes the external lookup configuration.
+     */
+    readonly extLookupConfigChange: _angular_core.OutputEmitterRef<RefLookupConfig>;
+    modelEntries: ThesaurusEntry[];
+    partTypeKeys: string[];
+    itemParts: Part[];
+    item: FormControl<Item | null>;
+    itemPart: FormControl<Part | null>;
+    partTypeKey: FormControl<string | null>;
+    gid: FormControl<string | null>;
+    label: FormControl<string | null>;
+    byTypeMode: FormControl<boolean>;
+    external: FormControl<boolean>;
+    form: FormGroup;
+    filter: PinRefLookupFilter;
+    pinFilterOptions?: IndexLookupDefinition;
+    lookupData?: PinLookupData;
+    constructor(_presetLookupDefs: IndexLookupDefinitions, itemLookupService: ItemRefLookupService, pinLookupService: PinRefLookupService, _itemService: ItemService, _thesService: ThesaurusService, _snackbar: MatSnackBar, formBuilder: FormBuilder);
+    private forceByItem;
+    private setupKeys;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private buildGid;
+    private buildLabel;
+    private getTarget;
+    private emitChange;
+    private updateTarget;
+    private updateForm;
+    /**
+     * Called when the item lookup changes (item is looked up
+     * by its title).
+     *
+     * @param item The item got from lookup.
+     */
+    onItemLookupChange(item: unknown): void;
+    private loadItemInfo;
+    /**
+     * Called when the pin lookup change. A pin is looked up by its
+     * name and value (=the filter's text), and optionally by:
+     * - its index lookup definition (selected by partTypeKey).
+     * - its item (defined by item, in filter).
+     * - its part (defined by itemPart, in filter).
+     *
+     * @param info The pin info from pin lookup.
+     */
+    onPinLookupChange(info: unknown): void;
+    onExtItemChange(event: RefLookupSetEvent): void;
+    onExtMoreRequest(event: RefLookupSetEvent): void;
+    onCopied(): void;
+    onExtConfigChange(config: RefLookupConfig): void;
+    close(): void;
+    save(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PinTargetLookupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PinTargetLookupComponent, "cadmus-pin-target-lookup", never, { "pinByTypeMode": { "alias": "pinByTypeMode"; "required": false; "isSignal": true; }; "canSwitchMode": { "alias": "canSwitchMode"; "required": false; "isSignal": true; }; "canEditTarget": { "alias": "canEditTarget"; "required": false; "isSignal": true; }; "lookupDefinitions": { "alias": "lookupDefinitions"; "required": false; "isSignal": true; }; "extLookupConfigs": { "alias": "extLookupConfigs"; "required": false; "isSignal": true; }; "internalDefault": { "alias": "internalDefault"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "defaultPartTypeKey": { "alias": "defaultPartTypeKey"; "required": false; "isSignal": true; }; }, { "pinByTypeMode": "pinByTypeModeChange"; "canSwitchMode": "canSwitchModeChange"; "lookupDefinitions": "lookupDefinitionsChange"; "target": "targetChange"; "editorClose": "editorClose"; "extMoreRequest": "extMoreRequest"; "extLookupConfigChange": "extLookupConfigChange"; }, never, never, true, never>;
+}
+
+/**
+ * An asserted composite ID. This can be an external ID, having only the ID value
+ * as its target.gid property; or a lookup ID, with a pin-based target.
+ * In both cases, we can add a tag, a scope, and an assertion.
+ */
+interface AssertedCompositeId {
+    target: PinTarget;
+    tag?: string;
+    scope?: string;
+    assertion?: Assertion;
+}
+/**
+ * The key to be used to retrieve the external lookup configs from the
+ * settings storage. This is equal to the selector of
+ * AssertedCompositeIdComponent plus ".configs".
+ */
+declare const ASSERTED_COMPOSITE_ID_CONFIGS_KEY = "cadmus-refs-asserted-composite-id.configs";
+/**
+ * An asserted composite ID editor. This allows the user to edit an asserted
+ * composite ID, which can be an external ID or a lookup ID.
+ */
+declare class AssertedCompositeIdComponent implements OnInit, OnDestroy {
+    lookupService: PinRefLookupService;
+    lookupDefs: IndexLookupDefinitions;
+    private _sub?;
+    private _updatingForm;
+    extLookupConfigs: RefLookupConfig[];
+    targetExpanded: boolean;
+    target: FormControl<PinTarget | null>;
+    scope: FormControl<string | null>;
+    tag: FormControl<string | null>;
+    assertion: FormControl<Assertion | null>;
+    form: FormGroup;
+    readonly idScopeEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly idTagEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly assTagEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly refTypeEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly refTagEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * The ID being edited.
+     */
+    readonly id: _angular_core.ModelSignal<AssertedCompositeId | undefined>;
+    /**
+     * True if when a new ID is set it should be internal rather than
+     * external by default.
+     */
+    readonly internalDefault: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * True if the UI has a submit button.
+     */
+    readonly hasSubmit: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * True when the internal UI preselected mode should be by type rather than
+     * by item. User can change mode unless modeSwitching is false.
+     */
+    readonly pinByTypeMode: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * True when the user can switch between by-type and by-item mode in
+     * the internal UI.
+     */
+    readonly canSwitchMode: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * True when the user can edit the target's gid/label for internal targets.
+     */
+    readonly canEditTarget: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * The lookup definitions to be used for the by-type lookup in the internal UI.
+     * If not specified, the lookup definitions will be got via injection
+     * when available; if the injected definitions are empty, the
+     * lookup definitions will be built from the model-types thesaurus;
+     * if this is not available either, the by-type lookup will be
+     * disabled.
+     */
+    readonly lookupDefinitions: _angular_core.InputSignal<IndexLookupDefinitions | undefined>;
+    /**
+     * The default part type key to be used.
+     */
+    readonly defaultPartTypeKey: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Emitted whenever the user requests to close the editor.
+     */
+    readonly editorClose: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emitted when the user requests more.
+     */
+    readonly extMoreRequest: _angular_core.OutputEmitterRef<RefLookupSetEvent>;
+    constructor(formBuilder: FormBuilder, lookupService: PinRefLookupService, lookupDefs: IndexLookupDefinitions, settings: RamStorageService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onAssertionChange(assertion: Assertion | undefined): void;
+    onTargetChange(target?: PinTarget): void;
+    private updateForm;
+    private getId;
+    emitIdChange(): void;
+    onEditorClose(): void;
+    onExtMoreRequest(event: RefLookupSetEvent): void;
+    onExtLookupConfigChange(config: RefLookupConfig): void;
+    cancel(): void;
+    save(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AssertedCompositeIdComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AssertedCompositeIdComponent, "cadmus-refs-asserted-composite-id", never, { "idScopeEntries": { "alias": "idScopeEntries"; "required": false; "isSignal": true; }; "idTagEntries": { "alias": "idTagEntries"; "required": false; "isSignal": true; }; "assTagEntries": { "alias": "assTagEntries"; "required": false; "isSignal": true; }; "refTypeEntries": { "alias": "refTypeEntries"; "required": false; "isSignal": true; }; "refTagEntries": { "alias": "refTagEntries"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "internalDefault": { "alias": "internalDefault"; "required": false; "isSignal": true; }; "hasSubmit": { "alias": "hasSubmit"; "required": false; "isSignal": true; }; "pinByTypeMode": { "alias": "pinByTypeMode"; "required": false; "isSignal": true; }; "canSwitchMode": { "alias": "canSwitchMode"; "required": false; "isSignal": true; }; "canEditTarget": { "alias": "canEditTarget"; "required": false; "isSignal": true; }; "lookupDefinitions": { "alias": "lookupDefinitions"; "required": false; "isSignal": true; }; "defaultPartTypeKey": { "alias": "defaultPartTypeKey"; "required": false; "isSignal": true; }; }, { "id": "idChange"; "editorClose": "editorClose"; "extMoreRequest": "extMoreRequest"; }, never, never, true, never>;
+}
+
+/**
+ * Asserted composite IDs editor.
+ */
+declare class AssertedCompositeIdsComponent {
+    private _dialogService;
+    private _ids;
+    private _editedIndex;
+    edited?: AssertedCompositeId;
+    /**
+     * The asserted IDs.
+     */
+    get ids(): AssertedCompositeId[];
+    set ids(value: AssertedCompositeId[]);
+    readonly idScopeEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly idTagEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly assTagEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly refTypeEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    readonly refTagEntries: _angular_core.InputSignal<ThesaurusEntry[] | undefined>;
+    /**
+     * True when the internal UI preselected mode should be by type rather than
+     * by item. User can change mode unless modeSwitching is false.
+     */
+    readonly pinByTypeMode: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * True when the user can switch between by-type and by-item mode in
+     * the internal UI.
+     */
+    readonly canSwitchMode: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * True when the user can edit the target's gid/label for internal targets.
+     */
+    readonly canEditTarget: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * The lookup definitions to be used for the by-type lookup in the internal UI.
+     * If not specified, the lookup definitions will be got via injection
+     * when available; if the injected definitions are empty, the
+     * lookup definitions will be built from the model-types thesaurus;
+     * if this is not available either, the by-type lookup will be
+     * disabled.
+     */
+    readonly lookupDefinitions: _angular_core.InputSignal<IndexLookupDefinitions | undefined>;
+    /**
+     * The default part type key.
+     */
+    readonly defaultPartTypeKey: _angular_core.InputSignal<string | undefined>;
+    /**
+     * True if when a new ID is set it should be internal rather than
+     * external by default.
+     */
+    readonly internalDefault: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Emitted whenever any ID changes.
+     */
+    readonly idsChange: _angular_core.OutputEmitterRef<AssertedCompositeId[]>;
+    entries: FormControl<AssertedCompositeId[]>;
+    form: FormGroup;
+    constructor(formBuilder: FormBuilder, _dialogService: DialogService);
+    private updateForm;
+    private emitIdsChange;
+    addId(): void;
+    editId(id: AssertedCompositeId, index: number): void;
+    closeId(): void;
+    saveId(entry: AssertedCompositeId): void;
+    deleteId(index: number): void;
+    moveIdUp(index: number): void;
+    moveIdDown(index: number): void;
+    onIdChange(id?: AssertedCompositeId): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AssertedCompositeIdsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AssertedCompositeIdsComponent, "cadmus-refs-asserted-composite-ids", never, { "ids": { "alias": "ids"; "required": false; }; "idScopeEntries": { "alias": "idScopeEntries"; "required": false; "isSignal": true; }; "idTagEntries": { "alias": "idTagEntries"; "required": false; "isSignal": true; }; "assTagEntries": { "alias": "assTagEntries"; "required": false; "isSignal": true; }; "refTypeEntries": { "alias": "refTypeEntries"; "required": false; "isSignal": true; }; "refTagEntries": { "alias": "refTagEntries"; "required": false; "isSignal": true; }; "pinByTypeMode": { "alias": "pinByTypeMode"; "required": false; "isSignal": true; }; "canSwitchMode": { "alias": "canSwitchMode"; "required": false; "isSignal": true; }; "canEditTarget": { "alias": "canEditTarget"; "required": false; "isSignal": true; }; "lookupDefinitions": { "alias": "lookupDefinitions"; "required": false; "isSignal": true; }; "defaultPartTypeKey": { "alias": "defaultPartTypeKey"; "required": false; "isSignal": true; }; "internalDefault": { "alias": "internalDefault"; "required": false; "isSignal": true; }; }, { "idsChange": "idsChange"; }, never, never, true, never>;
+}
+
+export { ASSERTED_COMPOSITE_ID_CONFIGS_KEY, AssertedCompositeIdComponent, AssertedCompositeIdsComponent, AssertedIdComponent, AssertedIdsComponent, ItemRefLookupService, PinRefLookupService, PinTargetLookupComponent, ScopedPinLookupComponent };
+export type { AssertedCompositeId, AssertedId, PinLookupData, PinRefLookupFilter, PinTarget };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myrmidon/cadmus-refs-asserted-ids",
-  "version": "9.0.0",
+  "version": "10.0.0",
   "description": "Cadmus - asserted IDs components.",
   "keywords": [
     "Cadmus",
@@ -15,11 +15,11 @@
     "name": "Daniele Fusi"
   },
   "peerDependencies": {
-    "@angular/common": "^19.0.0",
-    "@angular/core": "^19.0.0",
-    "@myrmidon/ngx-mat-tools": "^0.0.1",
-    "@myrmidon/cadmus-api": "^11.0.0",
-    "@myrmidon/cadmus-refs-assertion": "^9.0.0"
+    "@angular/common": "^20.0.0",
+    "@angular/core": "^20.0.0",
+    "@myrmidon/ngx-mat-tools": "^1.0.0",
+    "@myrmidon/cadmus-api": "^13.0.0",
+    "@myrmidon/cadmus-refs-assertion": "^10.0.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"

package/lib/asserted-composite-id/asserted-composite-id.component.d.ts

@@ -1,111 +0,0 @@
-import { OnDestroy, OnInit } from '@angular/core';
-import { FormBuilder, FormControl, FormGroup } from '@angular/forms';
-import { RamStorageService } from '@myrmidon/ngx-tools';
-import { IndexLookupDefinitions, ThesaurusEntry } from '@myrmidon/cadmus-core';
-import { Assertion } from '@myrmidon/cadmus-refs-assertion';
-import { RefLookupConfig, RefLookupSetEvent } from '@myrmidon/cadmus-refs-lookup';
-import { PinRefLookupService } from '../services/pin-ref-lookup.service';
-import { PinTarget } from '../pin-target-lookup/pin-target-lookup.component';
-import * as i0 from "@angular/core";
-/**
- * An asserted composite ID. This can be an external ID, having only the ID value
- * as its target.gid property; or a lookup ID, with a pin-based target.
- * In both cases, we can add a tag, a scope, and an assertion.
- */
-export interface AssertedCompositeId {
-    target: PinTarget;
-    tag?: string;
-    scope?: string;
-    assertion?: Assertion;
-}
-/**
- * The key to be used to retrieve the external lookup configs from the
- * settings storage. This is equal to the selector of
- * AssertedCompositeIdComponent plus ".configs".
- */
-export declare const ASSERTED_COMPOSITE_ID_CONFIGS_KEY = "cadmus-refs-asserted-composite-id.configs";
-/**
- * An asserted composite ID editor. This allows the user to edit an asserted
- * composite ID, which can be an external ID or a lookup ID.
- */
-export declare class AssertedCompositeIdComponent implements OnInit, OnDestroy {
-    lookupService: PinRefLookupService;
-    lookupDefs: IndexLookupDefinitions;
-    private _sub?;
-    private _updatingForm;
-    extLookupConfigs: RefLookupConfig[];
-    targetExpanded: boolean;
-    target: FormControl<PinTarget | null>;
-    scope: FormControl<string | null>;
-    tag: FormControl<string | null>;
-    assertion: FormControl<Assertion | null>;
-    form: FormGroup;
-    readonly idScopeEntries: import("@angular/core").InputSignal<ThesaurusEntry[] | undefined>;
-    readonly idTagEntries: import("@angular/core").InputSignal<ThesaurusEntry[] | undefined>;
-    readonly assTagEntries: import("@angular/core").InputSignal<ThesaurusEntry[] | undefined>;
-    readonly refTypeEntries: import("@angular/core").InputSignal<ThesaurusEntry[] | undefined>;
-    readonly refTagEntries: import("@angular/core").InputSignal<ThesaurusEntry[] | undefined>;
-    /**
-     * The ID being edited.
-     */
-    readonly id: import("@angular/core").ModelSignal<AssertedCompositeId | undefined>;
-    /**
-     * True if when a new ID is set it should be internal rather than
-     * external by default.
-     */
-    readonly internalDefault: import("@angular/core").InputSignal<boolean | undefined>;
-    /**
-     * True if the UI has a submit button.
-     */
-    readonly hasSubmit: import("@angular/core").InputSignal<boolean | undefined>;
-    /**
-     * True when the internal UI preselected mode should be by type rather than
-     * by item. User can change mode unless modeSwitching is false.
-     */
-    readonly pinByTypeMode: import("@angular/core").InputSignal<boolean | undefined>;
-    /**
-     * True when the user can switch between by-type and by-item mode in
-     * the internal UI.
-     */
-    readonly canSwitchMode: import("@angular/core").InputSignal<boolean | undefined>;
-    /**
-     * True when the user can edit the target's gid/label for internal targets.
-     */
-    readonly canEditTarget: import("@angular/core").InputSignal<boolean | undefined>;
-    /**
-     * The lookup definitions to be used for the by-type lookup in the internal UI.
-     * If not specified, the lookup definitions will be got via injection
-     * when available; if the injected definitions are empty, the
-     * lookup definitions will be built from the model-types thesaurus;
-     * if this is not available either, the by-type lookup will be
-     * disabled.
-     */
-    readonly lookupDefinitions: import("@angular/core").InputSignal<IndexLookupDefinitions | undefined>;
-    /**
-     * The default part type key to be used.
-     */
-    readonly defaultPartTypeKey: import("@angular/core").InputSignal<string | undefined>;
-    /**
-     * Emitted whenever the user requests to close the editor.
-     */
-    readonly editorClose: import("@angular/core").OutputEmitterRef<void>;
-    /**
-     * Emitted when the user requests more.
-     */
-    readonly extMoreRequest: import("@angular/core").OutputEmitterRef<RefLookupSetEvent>;
-    constructor(formBuilder: FormBuilder, lookupService: PinRefLookupService, lookupDefs: IndexLookupDefinitions, settings: RamStorageService);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    onAssertionChange(assertion: Assertion | undefined): void;
-    onTargetChange(target?: PinTarget): void;
-    private updateForm;
-    private getId;
-    emitIdChange(): void;
-    onEditorClose(): void;
-    onExtMoreRequest(event: RefLookupSetEvent): void;
-    onExtLookupConfigChange(config: RefLookupConfig): void;
-    cancel(): void;
-    save(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AssertedCompositeIdComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<AssertedCompositeIdComponent, "cadmus-refs-asserted-composite-id", never, { "idScopeEntries": { "alias": "idScopeEntries"; "required": false; "isSignal": true; }; "idTagEntries": { "alias": "idTagEntries"; "required": false; "isSignal": true; }; "assTagEntries": { "alias": "assTagEntries"; "required": false; "isSignal": true; }; "refTypeEntries": { "alias": "refTypeEntries"; "required": false; "isSignal": true; }; "refTagEntries": { "alias": "refTagEntries"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "internalDefault": { "alias": "internalDefault"; "required": false; "isSignal": true; }; "hasSubmit": { "alias": "hasSubmit"; "required": false; "isSignal": true; }; "pinByTypeMode": { "alias": "pinByTypeMode"; "required": false; "isSignal": true; }; "canSwitchMode": { "alias": "canSwitchMode"; "required": false; "isSignal": true; }; "canEditTarget": { "alias": "canEditTarget"; "required": false; "isSignal": true; }; "lookupDefinitions": { "alias": "lookupDefinitions"; "required": false; "isSignal": true; }; "defaultPartTypeKey": { "alias": "defaultPartTypeKey"; "required": false; "isSignal": true; }; }, { "id": "idChange"; "editorClose": "editorClose"; "extMoreRequest": "extMoreRequest"; }, never, never, true, never>;
-}