@myrmidon/gve-core 0.0.1

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@myrmidon/gve-core" />
+export * from './public-api';

package/lib/components/animation-timeline/animation-timeline.component.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter } from '@angular/core';
+import { FormBuilder, FormControl, FormGroup } from '@angular/forms';
+import { GveAnimationTimeline, GveAnimationTween, GveAnimationVars } from '@myrmidon/gve-snapshot-view';
+import * as i0 from "@angular/core";
+export declare class AnimationTimelineComponent {
+    private _timeline?;
+    get timeline(): GveAnimationTimeline | undefined;
+    set timeline(value: GveAnimationTimeline | undefined | null);
+    /**
+     * The IDs of the elements that can be selected by the tween.
+     * This list is used to allow the user to select an element from a dropdown.
+     */
+    elementIds?: string[];
+    tags: string[];
+    readonly timelineChange: EventEmitter<GveAnimationTimeline>;
+    readonly cancel: EventEmitter<void>;
+    tag: FormControl<string>;
+    tweens: FormControl<GveAnimationTween[]>;
+    vars: FormControl<GveAnimationVars>;
+    form: FormGroup;
+    editedTweenIndex: number;
+    editedTween?: GveAnimationTween;
+    readonly selectors: {
+        0: string;
+        1: string;
+        2: string;
+    };
+    constructor(formBuilder: FormBuilder);
+    private updateForm;
+    addTween(): void;
+    editTween(index: number): void;
+    deleteTween(index: number): void;
+    closeTween(): void;
+    saveTween(tween: GveAnimationTween): void;
+    moveTweenUp(index: number): void;
+    moveTweenDown(index: number): void;
+    private getTimeline;
+    close(): void;
+    save(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimationTimelineComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnimationTimelineComponent, "gve-animation-timeline", never, { "timeline": { "alias": "timeline"; "required": false; }; "elementIds": { "alias": "elementIds"; "required": false; }; "tags": { "alias": "tags"; "required": false; }; }, { "timelineChange": "timelineChange"; "cancel": "cancel"; }, never, never, true, never>;
+}

package/lib/components/animation-tween/animation-tween.component.d.ts

@@ -0,0 +1,47 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { FormBuilder, FormControl, FormGroup } from '@angular/forms';
+import { GveAnimationTween, GveAnimationVars } from '@myrmidon/gve-snapshot-view';
+import * as i0 from "@angular/core";
+/**
+ * A component to edit an animation tween.
+ */
+export declare class AnimationTweenComponent implements OnInit, OnDestroy {
+    private _sub?;
+    private _tween?;
+    /**
+     * The tween to edit.
+     */
+    get tween(): GveAnimationTween | undefined;
+    set tween(value: GveAnimationTween | undefined | null);
+    /**
+     * The IDs of the elements that can be selected by the tween.
+     * This list is used to allow the user to select an element from a dropdown.
+     */
+    elementIds?: string[];
+    readonly tweenChange: EventEmitter<GveAnimationTween>;
+    readonly cancel: EventEmitter<void>;
+    label: FormControl<string>;
+    note: FormControl<string | null>;
+    type: FormControl<number>;
+    selector: FormControl<string>;
+    vars: FormControl<GveAnimationVars>;
+    vars2: FormControl<GveAnimationVars | null>;
+    position: FormControl<string | null>;
+    form: FormGroup;
+    elementId: FormControl<string | null>;
+    types: {
+        label: string;
+        value: number;
+    }[];
+    constructor(formBuilder: FormBuilder);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onVarsChange(vars: GveAnimationVars): void;
+    onVars2Change(vars: GveAnimationVars): void;
+    close(): void;
+    private updateForm;
+    private getTween;
+    save(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimationTweenComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnimationTweenComponent, "gve-animation-tween", never, { "tween": { "alias": "tween"; "required": false; }; "elementIds": { "alias": "elementIds"; "required": false; }; }, { "tweenChange": "tweenChange"; "cancel": "cancel"; }, never, never, true, never>;
+}

package/lib/components/animation-vars/animation-vars.component.d.ts

@@ -0,0 +1,30 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import { FormBuilder, FormControl, FormGroup } from '@angular/forms';
+import { GveAnimationVars } from '@myrmidon/gve-snapshot-view';
+import * as i0 from "@angular/core";
+interface VarViewModel {
+    name: string;
+    value: string | number | boolean;
+}
+export declare class AnimationVarsComponent {
+    private _vars;
+    get vars(): GveAnimationVars;
+    set vars(value: GveAnimationVars);
+    varsChange: EventEmitter<GveAnimationVars>;
+    nameInput?: ElementRef;
+    name: FormControl<string>;
+    value: FormControl<string>;
+    form: FormGroup;
+    editedVars: VarViewModel[];
+    constructor(formBuilder: FormBuilder);
+    private updateForm;
+    private getVars;
+    addVar(): void;
+    editVar(index: number): void;
+    deleteVar(index: number): void;
+    private parseValue;
+    saveVar(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimationVarsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnimationVarsComponent, "gve-animation-vars", never, { "vars": { "alias": "vars"; "required": false; }; }, { "varsChange": "varsChange"; }, never, never, true, never>;
+}
+export {};

package/lib/components/base-text-char/base-text-char.component.d.ts

@@ -0,0 +1,29 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface BaseTextChar {
+    id: number;
+    value: string;
+    label: string;
+    color: string;
+    borderColor: string;
+    emSize: number;
+}
+export interface BaseTextCharEvent {
+    char: BaseTextChar;
+    event: MouseEvent;
+}
+/**
+ * A component that displays a single character from a base text.
+ */
+export declare class BaseTextCharComponent {
+    private _char;
+    defaultColor: string;
+    defaultBorderColor: string;
+    defaultEmSize: number;
+    get char(): BaseTextChar | undefined;
+    set char(value: BaseTextChar | undefined | null);
+    charPick: EventEmitter<BaseTextCharEvent>;
+    onCharClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTextCharComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseTextCharComponent, "gve-base-text-char", never, { "char": { "alias": "char"; "required": false; }; }, { "charPick": "charPick"; }, never, never, true, never>;
+}

package/lib/components/base-text-editor/base-text-editor.component.d.ts

@@ -0,0 +1,40 @@
+import { EventEmitter } from '@angular/core';
+import { FormBuilder, FormControl, FormGroup } from '@angular/forms';
+import { CharNode, Feature } from '@myrmidon/gve-snapshot-view';
+import { DialogService } from '@myrmidon/ng-mat-tools';
+import { BaseTextCharEvent } from '../base-text-char/base-text-char.component';
+import { VarBaseTextRange } from '../base-text-view/base-text-view.component';
+import * as i0 from "@angular/core";
+/**
+ * Editor for snapshot's base text. This can receive a string or an array
+ * of `CharNode` objects, and lets the user edit the text, character by
+ * character, optionally also setting its features.
+ */
+export declare class BaseTextEditorComponent {
+    private _dialogService;
+    private _text;
+    /**
+     * The text to edit. In input this can be a string, an array of `CharNode`
+     * objects. In output this will be an array of `CharNode` objects.
+     */
+    get text(): CharNode[];
+    set text(value: string | CharNode[] | undefined | null);
+    /**
+     * Emits the edited text as an array of `CharNode`'s whenever it changes.
+     */
+    readonly textChange: EventEmitter<CharNode[]>;
+    userText: FormControl<string>;
+    form: FormGroup;
+    selectedChar?: CharNode;
+    selectedCharLabel?: string;
+    textRange?: VarBaseTextRange;
+    constructor(formBuilder: FormBuilder, _dialogService: DialogService);
+    private resetSelectedChar;
+    onSelectedChar(event: BaseTextCharEvent): void;
+    onFeaturesChange(features: Feature[]): void;
+    onRangePick(range: VarBaseTextRange): void;
+    patchTextFromUser(): void;
+    setTextFromUser(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTextEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseTextEditorComponent, "gve-base-text-editor", never, { "text": { "alias": "text"; "required": false; }; }, { "textChange": "textChange"; }, never, never, true, never>;
+}

package/lib/components/base-text-view/base-text-view.component.d.ts

@@ -0,0 +1,29 @@
+import { EventEmitter } from '@angular/core';
+import { BaseTextChar, BaseTextCharEvent } from '../base-text-char/base-text-char.component';
+import { CharNode } from '@myrmidon/gve-snapshot-view';
+import * as i0 from "@angular/core";
+export interface VarBaseTextRange {
+    at: number;
+    run: number;
+}
+/**
+ * A component to display a selectable base text.
+ */
+export declare class BaseTextViewComponent {
+    private _text?;
+    private _lastSelectedChar?;
+    defaultColor: string;
+    defaultBorderColor: string;
+    selectionColor: string;
+    hasLineNumber: boolean;
+    get text(): string | CharNode[] | undefined;
+    set text(value: string | CharNode[] | undefined | null);
+    charPick: EventEmitter<BaseTextCharEvent>;
+    rangePick: EventEmitter<VarBaseTextRange>;
+    lines: BaseTextChar[][];
+    private buildLines;
+    private resetColors;
+    onCharPick(event: BaseTextCharEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTextViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseTextViewComponent, "gve-base-text-view", never, { "defaultColor": { "alias": "defaultColor"; "required": false; }; "defaultBorderColor": { "alias": "defaultBorderColor"; "required": false; }; "selectionColor": { "alias": "selectionColor"; "required": false; }; "hasLineNumber": { "alias": "hasLineNumber"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, { "charPick": "charPick"; "rangePick": "rangePick"; }, never, never, true, never>;
+}

package/lib/components/chain-operation-editor/chain-operation-editor.component.d.ts

@@ -0,0 +1,102 @@
+/// <reference types="monaco-editor/monaco" />
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { FormBuilder, FormControl, FormGroup } from '@angular/forms';
+import { Clipboard } from '@angular/cdk/clipboard';
+import { CharChainOperation, Feature, OperationFeature, OperationType, OperationSource, SnapshotBase } from '@myrmidon/gve-snapshot-view';
+import { SettingsService } from '../../services/settings.service';
+import * as i0 from "@angular/core";
+/**
+ * A component for editing a variant generation operation.
+ */
+export declare class ChainOperationEditorComponent implements OnInit, OnDestroy {
+    private _clipboard;
+    private _settings;
+    private readonly _disposables;
+    private _editorModel?;
+    private _editor?;
+    private readonly _subs;
+    private readonly _nanoid;
+    private _operation;
+    private _editedSourceIndex;
+    private _snapshot;
+    /**
+     * The operation to edit.
+     */
+    get operation(): CharChainOperation | undefined | null;
+    set operation(value: CharChainOperation | undefined);
+    /**
+     * The snapshot the operation refers to.
+     */
+    get snapshot(): SnapshotBase | undefined;
+    set snapshot(value: SnapshotBase | undefined | null);
+    /**
+     * Whether to hide the preview request button.
+     */
+    hidePreview?: boolean;
+    /**
+     * Emits when the operation is changed.
+     */
+    readonly operationChange: EventEmitter<CharChainOperation>;
+    /**
+     * Emits when the operation preview is requested.
+     */
+    readonly operationPreview: EventEmitter<CharChainOperation>;
+    /**
+     * Emits when the operation editing is cancelled.
+     */
+    readonly operationCancel: EventEmitter<void>;
+    tabIndex: number;
+    id?: string;
+    hasTo: boolean;
+    hasToRun: boolean;
+    hasValue: boolean;
+    rank: FormControl<number>;
+    groupId: FormControl<string | null>;
+    features: FormControl<Feature[]>;
+    sources: FormControl<OperationSource[]>;
+    type: FormControl<OperationType>;
+    at: FormControl<number>;
+    atAsIndex: FormControl<boolean>;
+    to: FormControl<number>;
+    toAsIndex: FormControl<boolean>;
+    inputTag: FormControl<string | null>;
+    outputTag: FormControl<string | null>;
+    run: FormControl<number>;
+    toRun: FormControl<number>;
+    value: FormControl<string | null>;
+    svg: FormControl<string>;
+    elementFeatures: FormControl<Record<string, Feature[]>>;
+    dpFeatures: FormControl<Feature[]>;
+    form: FormGroup;
+    elements: SVGElement[];
+    editedElementId?: string;
+    editedSource?: OperationSource;
+    constructor(formBuilder: FormBuilder, _clipboard: Clipboard, _settings: SettingsService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private hasTextChanges;
+    onCreateEditor(editor: monaco.editor.IEditor): void;
+    onFeaturesChange(features: OperationFeature[]): void;
+    onDpFeaturesChange(features: Feature[]): void;
+    addSource(): void;
+    editSource(index: number): void;
+    closeSource(): void;
+    onSourceChange(source: OperationSource): void;
+    saveSvg(): void;
+    openSvgEditor(): void;
+    loadSvg(): void;
+    setSvgFromClipboard(): void;
+    private parseSvg;
+    onTabIndexChange(index: number): void;
+    editElementFeatures(element: SVGElement): void;
+    deleteElementFeatures(element: SVGElement): void;
+    onElementFeaturesChange(features: Feature[]): void;
+    private updateArgsUI;
+    private updateForm;
+    cancel(): void;
+    private getOperation;
+    requestPreview(): void;
+    save(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChainOperationEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChainOperationEditorComponent, "gve-chain-operation-editor", never, { "operation": { "alias": "operation"; "required": false; }; "snapshot": { "alias": "snapshot"; "required": false; }; "hidePreview": { "alias": "hidePreview"; "required": false; }; }, { "operationChange": "operationChange"; "operationPreview": "operationPreview"; "operationCancel": "operationCancel"; }, never, never, true, never>;
+}

package/lib/components/chain-result-view/chain-result-view.component.d.ts

@@ -0,0 +1,44 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { FormBuilder, FormControl } from '@angular/forms';
+import { OperationFeature } from '@myrmidon/gve-snapshot-view';
+import { VarBaseTextRange } from '../base-text-view/base-text-view.component';
+import { ChainOperationContextStep, CharChainResult } from '../../services/gve-api.service';
+import { BaseTextCharEvent } from '../base-text-char/base-text-char.component';
+import * as i0 from "@angular/core";
+/**
+ * Component to display a chain result.
+ */
+export declare class ChainResultViewComponent implements OnInit, OnDestroy {
+    private _subs?;
+    private _result?;
+    private _stepPickFrozen?;
+    /**
+     * The result to display.
+     */
+    get result(): CharChainResult | undefined;
+    set result(value: CharChainResult | undefined | null);
+    /**
+     * Emits when a result's step is picked.
+     */
+    stepPick: EventEmitter<ChainOperationContextStep>;
+    versionTags: string[];
+    tags: string[];
+    versionTag: FormControl<string | null>;
+    tag: FormControl<string | null>;
+    step?: ChainOperationContextStep;
+    selection?: string;
+    selectionFeatures: OperationFeature[];
+    constructor(formBuilder: FormBuilder);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private updateVersionTags;
+    private getTagFromVersion;
+    private updateForm;
+    private getNodeFeatures;
+    private findNode;
+    onStepCharPick(event: BaseTextCharEvent): void;
+    onStepRangePick(range: VarBaseTextRange): void;
+    onStepChange(step: ChainOperationContextStep): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChainResultViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChainResultViewComponent, "gve-chain-result-view", never, { "result": { "alias": "result"; "required": false; }; }, { "stepPick": "stepPick"; }, never, never, true, never>;
+}

package/lib/components/feature-editor/feature-editor.component.d.ts

@@ -0,0 +1,72 @@
+import { ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { FormBuilder, FormControl, FormGroup } from '@angular/forms';
+import { Feature, FeatureSetPolicy, LabeledId, OperationFeature } from '@myrmidon/gve-snapshot-view';
+import * as i0 from "@angular/core";
+/**
+ * Features map. This is used for features from closed sets,
+ * and lists the possible values for each feature.
+ */
+export interface FeatureMap {
+    [key: string]: LabeledId[];
+}
+/**
+ * Feature editor. This edits a single feature, either free or from
+ * a closed set. In the latter case you must define the set via
+ * the `labeledIds` input. Also, you can provide a map of features
+ * to values via the `map` input. This is useful when you want to
+ * provide a set of features and values to the user, and you want
+ * to provide human-readable labels for the values.
+ */
+export declare class FeatureEditorComponent implements OnInit, OnDestroy {
+    private _sub?;
+    private _feature?;
+    private _map?;
+    nameControl?: ElementRef;
+    /**
+     * The list of feature names to display in the name selection.
+     * This is used when you have a closed list of features.
+     */
+    featNames: LabeledId[] | undefined;
+    /**
+     * The feature values map. When specified and the user selects a feature
+     * name present in the map keys, the corresponding values will be used
+     * to populate the value selection.
+     */
+    get featValues(): FeatureMap | undefined;
+    set featValues(value: FeatureMap | undefined | null);
+    /**
+     * The feature to edit.
+     */
+    get feature(): Feature | OperationFeature | undefined;
+    set feature(value: Feature | OperationFeature | undefined | null);
+    /**
+     * True if the feature is a variant operation feature, which has
+     * additional properties like negation, global, and short-lived.
+     */
+    isVar: boolean;
+    /**
+     * Event emitted when the user cancels the feature editing.
+     */
+    featureCancel: EventEmitter<void>;
+    /**
+     * Event emitted when the user saves the edited feature.
+     */
+    featureChange: EventEmitter<OperationFeature | Feature>;
+    name: FormControl<string>;
+    value: FormControl<string>;
+    setPolicy: FormControl<FeatureSetPolicy>;
+    isNegated: FormControl<boolean>;
+    isGlobal: FormControl<boolean>;
+    isShortLived: FormControl<boolean>;
+    form: FormGroup;
+    nameIds?: LabeledId[];
+    constructor(formBuilder: FormBuilder);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private getLabeledIdsFor;
+    private updateForm;
+    cancel(): void;
+    save(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FeatureEditorComponent, "gve-feature-editor", never, { "featNames": { "alias": "featNames"; "required": false; }; "featValues": { "alias": "featValues"; "required": false; }; "feature": { "alias": "feature"; "required": false; }; "isVar": { "alias": "isVar"; "required": false; }; }, { "featureCancel": "featureCancel"; "featureChange": "featureChange"; }, never, never, true, never>;
+}

package/lib/components/feature-set-editor/feature-set-editor.component.d.ts

@@ -0,0 +1,55 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { FormBuilder, FormControl } from '@angular/forms';
+import { LabeledId, Feature, OperationFeature } from '@myrmidon/gve-snapshot-view';
+import { FeatureMap } from '../feature-editor/feature-editor.component';
+import * as i0 from "@angular/core";
+/**
+ * Editor for a set of features.
+ */
+export declare class FeatureSetEditorComponent implements OnInit, OnDestroy {
+    private _sub?;
+    private _features;
+    private _editedFeatureIndex;
+    /**
+     * True if the features are variable features.
+     */
+    isVar: boolean;
+    /**
+     * The list of feature names to display in the name selection.
+     * This is used when you have a closed list of features.
+     */
+    featNames: LabeledId[] | undefined;
+    /**
+     * The feature values map. When specified and the user selects a feature
+     * name present in the map keys, the corresponding values will be used
+     * to populate the value selection.
+     */
+    featValues: FeatureMap | undefined;
+    /**
+     * True to hide the feature filter.
+     */
+    noFilter: boolean;
+    /**
+     * The features to edit.
+     */
+    get features(): Feature[] | OperationFeature[];
+    set features(value: Feature[] | OperationFeature[]);
+    /**
+     * Emitted when the features change.
+     */
+    featuresChange: EventEmitter<Feature[] | OperationFeature[]>;
+    editedFeature?: Feature | OperationFeature;
+    filter: FormControl<string | null>;
+    filteredFeatures: Feature[] | OperationFeature[];
+    constructor(formBuilder: FormBuilder);
+    private applyFeatureFilter;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    addFeature(): void;
+    editFeature(feature: Feature | OperationFeature): void;
+    deleteFeature(feature: Feature | OperationFeature): void;
+    onFeatureChange(feature: Feature | OperationFeature): void;
+    onFeatureCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureSetEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FeatureSetEditorComponent, "gve-feature-set-editor", never, { "isVar": { "alias": "isVar"; "required": false; }; "featNames": { "alias": "featNames"; "required": false; }; "featValues": { "alias": "featValues"; "required": false; }; "noFilter": { "alias": "noFilter"; "required": false; }; "features": { "alias": "features"; "required": false; }; }, { "featuresChange": "featuresChange"; }, never, never, true, never>;
+}

package/lib/components/feature-set-view/feature-set-view.component.d.ts

@@ -0,0 +1,36 @@
+import { FormBuilder, FormControl } from '@angular/forms';
+import { Feature, LabeledId, OperationFeature } from '@myrmidon/gve-snapshot-view';
+import { FeatureMap } from '../feature-editor/feature-editor.component';
+import * as i0 from "@angular/core";
+export declare class FeatureSetViewComponent {
+    private _sub?;
+    private _features;
+    /**
+     * The features.
+     */
+    get features(): Feature[] | OperationFeature[];
+    set features(value: Feature[] | OperationFeature[]);
+    /**
+     * The list of feature names to display in the name selection.
+     * This is used when you have a closed list of features.
+     */
+    featNames: LabeledId[] | undefined;
+    /**
+     * The feature values map. When specified and the user selects a feature
+     * name present in the map keys, the corresponding values will be used
+     * to populate the value selection.
+     */
+    featValues: FeatureMap | undefined;
+    /**
+     * The minimum count of features required for filter to be visible.
+     */
+    minFilterCount: number;
+    filter: FormControl<string | null>;
+    filteredFeatures: Feature[] | OperationFeature[];
+    constructor(formBuilder: FormBuilder);
+    private applyFeatureFilter;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureSetViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FeatureSetViewComponent, "gve-feature-set-view", never, { "features": { "alias": "features"; "required": false; }; "featNames": { "alias": "featNames"; "required": false; }; "featValues": { "alias": "featValues"; "required": false; }; "minFilterCount": { "alias": "minFilterCount"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/ln-heights-editor/ln-heights-editor.component.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { FormBuilder, FormControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class LnHeightsEditorComponent implements OnInit, OnDestroy {
+    private _subs?;
+    private _heights?;
+    private _lineCount;
+    lineNumber: FormControl<number>;
+    height: FormControl<number>;
+    get lineCount(): number;
+    set lineCount(value: number);
+    get heights(): Record<number, number> | undefined;
+    set heights(value: Record<number, number> | undefined | null);
+    readonly heightsChange: EventEmitter<Record<number, number> | undefined>;
+    lineNumbers: number[];
+    constructor(formBuilder: FormBuilder);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LnHeightsEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LnHeightsEditorComponent, "gve-ln-heights-editor", never, { "lineCount": { "alias": "lineCount"; "required": false; }; "heights": { "alias": "heights"; "required": false; }; }, { "heightsChange": "heightsChange"; }, never, never, true, never>;
+}

package/lib/components/operation-source-editor/operation-source-editor.component.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from '@angular/core';
+import { FormBuilder, FormControl, FormGroup } from '@angular/forms';
+import { LabeledId, OperationSource } from '@myrmidon/gve-snapshot-view';
+import * as i0 from "@angular/core";
+export declare class OperationSourceEditorComponent {
+    private _source;
+    get source(): OperationSource | undefined;
+    set source(value: OperationSource | undefined | null);
+    ids?: LabeledId[];
+    types?: LabeledId[];
+    readonly sourceChange: EventEmitter<OperationSource | undefined>;
+    sourceCancel: EventEmitter<void>;
+    id: FormControl<string>;
+    type: FormControl<string>;
+    rank: FormControl<number>;
+    note: FormControl<string | null>;
+    form: FormGroup;
+    constructor(formBuilder: FormBuilder);
+    private updateForm;
+    cancel(): void;
+    save(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OperationSourceEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OperationSourceEditorComponent, "gve-operation-source-editor", never, { "source": { "alias": "source"; "required": false; }; "ids": { "alias": "ids"; "required": false; }; "types": { "alias": "types"; "required": false; }; }, { "sourceChange": "sourceChange"; "sourceCancel": "sourceCancel"; }, never, never, true, never>;
+}

package/lib/components/simple-tree/simple-tree.component.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { TreeNode } from '@myrmidon/gve-snapshot-view';
+import * as i0 from "@angular/core";
+export declare class SimpleTreeComponent implements OnInit {
+    private _node;
+    get node(): TreeNode<any> | undefined;
+    set node(value: TreeNode<any> | undefined);
+    selectedNode?: TreeNode<any> | null;
+    selectedNodeChange: EventEmitter<TreeNode<any> | null>;
+    level: number;
+    ngOnInit(): void;
+    private calculateLevel;
+    selectNode(node: TreeNode<any>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleTreeComponent, "gve-simple-tree", never, { "node": { "alias": "node"; "required": false; }; "selectedNode": { "alias": "selectedNode"; "required": false; }; }, { "selectedNodeChange": "selectedNodeChange"; }, never, never, true, never>;
+}