@honua/app-platform 0.1.4-beta.0 → 0.1.9-beta.0

package/web-components/feature-editor-workflow.js

@@ -36,6 +36,7 @@
 import { createEditSession, } from "../contract/edit-session.js";
 import { createEditSketchWorkflow, } from "../contract/edit-sketch.js";
 import { buildEditorFormModel, coerceEditorFieldValue, editorFieldsFromSchema, editorOperationAvailability, redactEditorAttachment, resolveActiveEditorSubtype, resolveEditorFields, resolveEditorOperations, } from "./feature-editor-model.js";
+import { createHonuaFeatureMutationReceipt } from "./feature-mutation.js";
 const EMPTY_UNDO = { canUndo: false, canRedo: false, undoDepth: 0, redoDepth: 0 };
 const CONFLICT_CHOICES = ["keep-mine", "discard-mine", "reload"];
 export class HonuaFeatureEditorWorkflow {
@@ -55,6 +56,9 @@ export class HonuaFeatureEditorWorkflow {
     #conflict;
     #message = "";
     #committedFeatureId;
+    #mutationReceipt;
+    #mutationId;
+    #offline;
     #abort;
     /**
      * The model whose in-flight submit was cancelled. Identity, not a boolean:
@@ -120,6 +124,40 @@ export class HonuaFeatureEditorWorkflow {
         const errors = dedupeValidationErrors([...sessionErrors, ...derivedErrors]);
         return { valid: errors.length === 0, errors };
     }
+    /** Review the exact current attempt without calling an adapter or changing workflow state. */
+    preflight() {
+        const model = this.#model;
+        const operation = this.#operation;
+        const validation = this.validate();
+        const blockers = [];
+        if (!model || !operation)
+            blockers.push("no-draft");
+        if (this.#conflict)
+            blockers.push("conflict");
+        if (this.#status === "submitting")
+            blockers.push("submitting");
+        if (this.#status === "queued")
+            blockers.push("queued");
+        const errors = validation.errors.map(({ code, fieldName, message }) => ({
+            code,
+            ...(fieldName ? { fieldName } : {}),
+            message,
+        }));
+        return Object.freeze({
+            ready: Boolean(model && operation && validation.valid && blockers.length === 0),
+            transported: false,
+            ...(model && this.#mutationId ? { mutationId: this.#mutationId } : {}),
+            source: Object.freeze({
+                sourceId: this.source.descriptor.id,
+                protocol: this.source.descriptor.protocol,
+            }),
+            ...(operation ? { operation } : {}),
+            ...(model && this.#identity ? { identity: Object.freeze({ ...this.#identity }) } : {}),
+            ...(model ? { draft: this.#draftSummary(model) } : {}),
+            validation: Object.freeze({ valid: validation.valid, errors: Object.freeze(errors) }),
+            blockers: Object.freeze(blockers),
+        });
+    }
     /** Current UI state. Never contains an attachment payload. */
     snapshot() {
         const model = this.#model;
@@ -128,6 +166,7 @@ export class HonuaFeatureEditorWorkflow {
             status: this.#status,
             ...(this.#operation ? { operation: this.#operation } : {}),
             ...(this.#identity ? { identity: this.#identity } : {}),
+            ...(model && this.#mutationId ? { mutationId: this.#mutationId } : {}),
             operations: this.operations(),
             ...(model && this.#operation
                 ? {
@@ -160,6 +199,8 @@ export class HonuaFeatureEditorWorkflow {
             busy: this.#status === "submitting",
             message: this.#message,
             ...(this.#committedFeatureId !== undefined ? { committedFeatureId: this.#committedFeatureId } : {}),
+            ...(this.#mutationReceipt ? { mutationReceipt: this.#mutationReceipt } : {}),
+            ...(this.#offline ? { offline: this.#offline } : {}),
         };
     }
     // ── draft lifecycle ────────────────────────────────────────────────────
@@ -198,6 +239,8 @@ export class HonuaFeatureEditorWorkflow {
      * recorded — never silently downgraded.
      */
     begin(operation, feature) {
+        if (this.#status === "queued")
+            return this.snapshot();
         const target = operation === "create" ? feature : (feature ?? this.#selection);
         this.#abort?.abort();
         // Any in-flight submit now belongs to a superseded draft, cancelled or not.
@@ -206,6 +249,9 @@ export class HonuaFeatureEditorWorkflow {
         this.#failures = [];
         this.#attachments = [];
         this.#committedFeatureId = undefined;
+        this.#mutationReceipt = undefined;
+        this.#mutationId = undefined;
+        this.#offline = undefined;
         this.#identity = this.#identityFor(target);
         // Resolve availability against the feature this draft would open on, not
         // the standing selection — an explicit `feature` argument may carry a
@@ -228,6 +274,7 @@ export class HonuaFeatureEditorWorkflow {
         this.#operation = operation;
         this.#baseline = target ? cloneFeature(target) : undefined;
         this.#model = this.#createModel(operation, target);
+        this.#mutationId = this.#allocateMutationId();
         if (operation === "create")
             this.#seedCreateDefaults();
         this.#status = "draft";
@@ -236,6 +283,8 @@ export class HonuaFeatureEditorWorkflow {
     }
     /** Discards the draft and aborts any in-flight submit. */
     cancel() {
+        if (this.#status === "queued")
+            return this.snapshot();
         if (this.#status === "submitting")
             this.#cancelledModel = this.#model;
         this.#abort?.abort();
@@ -246,14 +295,21 @@ export class HonuaFeatureEditorWorkflow {
         this.#conflict = undefined;
         this.#failures = [];
         this.#attachments = [];
+        this.#mutationReceipt = undefined;
+        this.#mutationId = undefined;
+        this.#offline = undefined;
         this.#status = "cancelled";
         this.#message = "Edit cancelled. Nothing was sent to the service.";
         return this.#notify();
     }
     /** Reverts the draft to the feature it opened on, keeping the draft open. */
     discardChanges() {
+        if (this.#status === "queued")
+            return this.snapshot();
         this.#model?.discard();
         this.#attachments = [];
+        this.#mutationReceipt = undefined;
+        this.#offline = undefined;
         this.#failures = [];
         this.#conflict = undefined;
         if (this.#model)
@@ -268,6 +324,8 @@ export class HonuaFeatureEditorWorkflow {
      * never reaches transport as a string).
      */
     setValue(name, raw) {
+        if (this.#status === "queued")
+            return this.snapshot();
         const model = this.#model;
         if (!model)
             return this.snapshot();
@@ -278,6 +336,8 @@ export class HonuaFeatureEditorWorkflow {
     }
     /** Records several already-typed attribute values at once. */
     setValues(values) {
+        if (this.#status === "queued")
+            return this.snapshot();
         const model = this.#model;
         if (!model)
             return this.snapshot();
@@ -288,6 +348,9 @@ export class HonuaFeatureEditorWorkflow {
     // ── geometry ───────────────────────────────────────────────────────────
     /** Arms a sketch tool. Unsupported tools report their reason rather than throwing. */
     startSketch(tool) {
+        if (this.#status === "queued") {
+            return { tool, state: "unsupported", reason: "The draft is locked while its offline edit is queued." };
+        }
         const model = this.#model;
         if (!model)
             return { tool, state: "unsupported", reason: "No edit draft is open." };
@@ -301,6 +364,8 @@ export class HonuaFeatureEditorWorkflow {
     }
     /** Applies a geometry through the sketch workflow (undoable). */
     setGeometry(tool, geometry) {
+        if (this.#status === "queued")
+            return this.snapshot();
         const model = this.#model;
         if (!model)
             return this.snapshot();
@@ -309,6 +374,8 @@ export class HonuaFeatureEditorWorkflow {
         return this.#notify();
     }
     undo() {
+        if (this.#status === "queued")
+            return false;
         const undone = this.#model?.undo() ?? false;
         if (undone) {
             this.#afterEdit();
@@ -317,6 +384,8 @@ export class HonuaFeatureEditorWorkflow {
         return undone;
     }
     redo() {
+        if (this.#status === "queued")
+            return false;
         const redone = this.#model?.redo() ?? false;
         if (redone) {
             this.#afterEdit();
@@ -330,6 +399,8 @@ export class HonuaFeatureEditorWorkflow {
      * only redacted metadata enters the snapshot.
      */
     stageAttachment(attachment, options = {}) {
+        if (this.#status === "queued")
+            return this.snapshot();
         const model = this.#model;
         if (!model)
             return this.snapshot();
@@ -340,6 +411,8 @@ export class HonuaFeatureEditorWorkflow {
     }
     /** Stages an attachment deletion. */
     stageAttachmentDelete(attachmentIds, options = {}) {
+        if (this.#status === "queued")
+            return this.snapshot();
         const model = this.#model;
         if (!model)
             return this.snapshot();
@@ -356,6 +429,8 @@ export class HonuaFeatureEditorWorkflow {
      * attachments; undo history restarts because tool support is a new baseline.
      */
     configureSketchTools(tools) {
+        if (this.#status === "queued")
+            return this.snapshot();
         // Idempotent: re-declaring the same tool support must not rebuild an open
         // draft (a sketch adapter may re-announce it on every attach).
         if (JSON.stringify(this.#sketchTools ?? null) === JSON.stringify(tools))
@@ -387,6 +462,16 @@ export class HonuaFeatureEditorWorkflow {
         if (!model || !operation) {
             return this.#preflightRejection("create", "No edit draft is open.", "validation");
         }
+        if (this.#status === "queued") {
+            return {
+                status: "queued",
+                operation,
+                transported: false,
+                failures: this.#failures,
+                attachments: this.#attachments,
+                snapshot: this.snapshot(),
+            };
+        }
         if (this.#conflict) {
             return this.#preflightRejection(operation, "Resolve the conflicting change before submitting again.", "conflict", "conflict");
         }
@@ -401,8 +486,12 @@ export class HonuaFeatureEditorWorkflow {
             this.#message = "The draft was not sent: fix the highlighted problems first.";
             return this.#commit(operation, false);
         }
+        const mutationId = this.#mutationId ?? this.#allocateMutationId();
+        this.#mutationId = mutationId;
         this.#status = "submitting";
         this.#failures = [];
+        this.#mutationReceipt = undefined;
+        this.#offline = undefined;
         this.#message = `Applying the ${operation}…`;
         this.#notify();
         const result = await model.submit();
@@ -426,6 +515,25 @@ export class HonuaFeatureEditorWorkflow {
         }
         this.#failures = result.failures.map(normalizeFailure);
         this.#attachments = attachmentDraftsFromResult(model, result.attachmentResults);
+        if (result.status === "succeeded" || result.status === "partial") {
+            const committedFeatureId = result.committedFeatureId ?? this.#identity?.featureId;
+            const feature = operation === "delete" ? undefined : featureAfterCommit(model.snapshot().feature, committedFeatureId);
+            this.#mutationReceipt = createHonuaFeatureMutationReceipt({
+                mutationId,
+                acceptedAt: this.#options.now?.() ?? new Date().toISOString(),
+                sourceId: this.source.descriptor.id,
+                protocol: this.source.descriptor.protocol,
+                operation,
+                status: result.status === "succeeded" ? "accepted" : "partially-accepted",
+                ...(committedFeatureId !== undefined ? { featureId: committedFeatureId } : {}),
+                ...(feature ? { feature } : {}),
+                attachmentMutations: result.attachmentResults.length,
+                optimistic: result.optimistic,
+            });
+        }
+        else {
+            this.#mutationReceipt = undefined;
+        }
         const conflictFailure = result.failures.find((failure) => failure.kind === "conflict");
         if (result.status === "succeeded") {
             this.#status = "committed";
@@ -459,10 +567,89 @@ export class HonuaFeatureEditorWorkflow {
         if (this.#status === "submitting") {
             return this.#preflightRejection(this.#operation ?? "create", "An edit is already in flight.", "validation");
         }
+        if (this.#status === "queued")
+            return this.submit();
         if (this.#status !== "conflict")
             this.#status = "draft";
         return this.submit();
     }
+    /**
+     * Project a durable offline queue transition into the online workflow's
+     * recoverable states. The queue remains authoritative; only identities and
+     * reason codes enter the component, never credentials or persisted payloads.
+     */
+    applyOfflineState(state) {
+        if (state.sourceId !== this.source.descriptor.id || !this.#model || !this.#operation)
+            return this.snapshot();
+        this.#mutationId = state.idempotencyKey;
+        this.#offline = Object.freeze({ ...state });
+        this.#failures = [];
+        if (state.state === "pending" || state.state === "retryable") {
+            this.#conflict = undefined;
+            this.#status = "queued";
+            this.#message =
+                state.state === "retryable"
+                    ? `The edit remains offline and will retry${state.retryAt ? ` after ${state.retryAt}` : ""}.`
+                    : "The edit is saved in the offline queue and will apply after reconnect.";
+            return this.#notify();
+        }
+        if (state.state === "conflicted") {
+            this.#status = "conflict";
+            this.#conflict = {
+                reason: state.conflictId
+                    ? `Offline replay conflict ${state.conflictId} requires a decision.`
+                    : "The offline edit conflicts with the current server feature.",
+                ...(this.#identity?.version !== undefined ? { mine: this.#identity.version } : {}),
+                ...(state.serverGeneration !== undefined ? { theirs: state.serverGeneration } : {}),
+                choices: CONFLICT_CHOICES,
+            };
+            this.#message = "The offline edit conflicted after reconnect. Choose how to resolve it.";
+            return this.#notify();
+        }
+        if (state.state === "cancelled") {
+            this.#conflict = undefined;
+            this.#status = "rejected";
+            this.#failures = [
+                {
+                    kind: "transport",
+                    operation: "session",
+                    description: state.reasonCode
+                        ? `The offline edit was cancelled: ${state.reasonCode}.`
+                        : "The offline edit was cancelled before it reached the service.",
+                },
+            ];
+            this.#message = this.#failures[0]?.description ?? "The offline edit was cancelled.";
+            return this.#notify();
+        }
+        if (state.state === "discarded") {
+            this.#conflict = undefined;
+            this.#model = undefined;
+            this.#operation = undefined;
+            this.#baseline = undefined;
+            this.#status = "idle";
+            this.#message = "The offline edit was discarded; the server version remains authoritative.";
+            return this.#notify();
+        }
+        const operation = this.#operation;
+        this.#conflict = undefined;
+        const featureId = this.#identity?.featureId;
+        const feature = operation === "delete" ? undefined : featureAfterCommit(this.#model.snapshot().feature, featureId);
+        this.#mutationReceipt = createHonuaFeatureMutationReceipt({
+            mutationId: state.idempotencyKey,
+            acceptedAt: state.appliedAt ?? this.#options.now?.() ?? new Date().toISOString(),
+            sourceId: this.source.descriptor.id,
+            protocol: this.source.descriptor.protocol,
+            operation,
+            status: "accepted",
+            ...(featureId !== undefined ? { featureId } : {}),
+            ...(feature ? { feature } : {}),
+        });
+        this.#status = "committed";
+        this.#committedFeatureId = featureId;
+        this.#baseline = cloneFeature(this.#model.snapshot().feature);
+        this.#message = "The offline edit was accepted after reconnect.";
+        return this.#notify();
+    }
     // ── conflict resolution ────────────────────────────────────────────────
     /**
      * Records an explicit decision for a parked conflict.
@@ -478,6 +665,10 @@ export class HonuaFeatureEditorWorkflow {
         const conflict = this.#conflict;
         if (!conflict)
             return this.snapshot();
+        if (this.#offline?.state === "conflicted") {
+            this.#message = "Resolve this conflict through the offline queue so the durable edit and the UI stay consistent.";
+            return this.#notify();
+        }
         if (choice === "reload") {
             this.#conflict = undefined;
             this.#model = undefined;
@@ -559,6 +750,8 @@ export class HonuaFeatureEditorWorkflow {
      *   untouched and parked until {@link resolveConflict} records a decision.
      */
     applyExternalChange(feature) {
+        if (this.#status === "queued")
+            return "ignored";
         const model = this.#model;
         const identity = this.#identity;
         if (!model || identity === undefined || identity.featureId === undefined)
@@ -681,10 +874,43 @@ export class HonuaFeatureEditorWorkflow {
             ...(token !== undefined ? { version: token } : {}),
         };
     }
+    #allocateMutationId() {
+        const value = this.#options.mutationId?.() ?? defaultMutationId(this.source.descriptor.id);
+        const normalized = value.trim();
+        if (!normalized)
+            throw new TypeError("mutationId must be a non-empty string.");
+        return normalized;
+    }
+    #draftSummary(model) {
+        const feature = model.snapshot().feature;
+        const current = feature.attributes;
+        const baseline = (this.#baseline?.attributes ?? {});
+        const changedFields = [...new Set([...Object.keys(baseline), ...Object.keys(current)])]
+            .filter((field) => !sameScalar(baseline[field], current[field]))
+            .sort();
+        const geometry = sameScalar(this.#baseline?.geometry, feature.geometry)
+            ? "unchanged"
+            : feature.geometry === null || feature.geometry === undefined
+                ? "cleared"
+                : "set";
+        const attachments = { add: 0, update: 0, delete: 0 };
+        for (const attachment of this.#attachments)
+            attachments[attachment.operation] += 1;
+        return Object.freeze({
+            dirty: model.dirty(),
+            changedFields: Object.freeze(changedFields),
+            geometry,
+            attachments: Object.freeze(attachments),
+        });
+    }
     #afterEdit() {
         if (this.#status === "committed" || this.#status === "rejected" || this.#status === "cancelled") {
+            if (this.#status === "committed")
+                this.#mutationId = this.#allocateMutationId();
             this.#status = "draft";
             this.#failures = [];
+            this.#mutationReceipt = undefined;
+            this.#offline = undefined;
             this.#message = draftMessage(this.#operation ?? "update");
         }
     }
@@ -708,6 +934,7 @@ export class HonuaFeatureEditorWorkflow {
             failures: this.#failures,
             attachments: this.#attachments,
             snapshot: this.snapshot(),
+            ...(this.#mutationReceipt ? { mutationReceipt: this.#mutationReceipt } : {}),
         };
     }
     /**
@@ -738,6 +965,7 @@ export class HonuaFeatureEditorWorkflow {
             failures: this.#failures,
             attachments: this.#attachments,
             snapshot,
+            ...(this.#mutationReceipt ? { mutationReceipt: this.#mutationReceipt } : {}),
         };
     }
     #notify() {
@@ -887,3 +1115,15 @@ function sameScalar(left, right) {
     }
     return String(left) === String(right);
 }
+let mutationSequence = 0;
+function defaultMutationId(sourceId) {
+    const randomUuid = globalThis.crypto?.randomUUID;
+    if (randomUuid)
+        return randomUuid.call(globalThis.crypto);
+    mutationSequence += 1;
+    return `${String(sourceId)}:${Date.now()}:${mutationSequence}`;
+}
+function featureAfterCommit(feature, featureId) {
+    const cloned = cloneFeature(feature);
+    return featureId === undefined ? cloned : { ...cloned, id: featureId };
+}

package/web-components/feature-editor.d.ts

@@ -41,16 +41,22 @@
  * @module
  */
 import type { CanonicalFeature } from "../contract/types.js";
-import type { HonuaFeatureEditorCommit, HonuaFeatureEditorSnapshot, HonuaFeatureEditorWorkflow } from "./feature-editor-workflow.js";
+import type { HonuaApplicationContext, HonuaApplicationContextChangeEvent } from "./application-context.js";
+import type { HonuaFeatureEditorCommit, HonuaFeatureEditorConflictChoice, HonuaFeatureEditorOfflineState, HonuaFeatureEditorPreflight, HonuaFeatureEditorSnapshot, HonuaFeatureEditorWorkflow } from "./feature-editor-workflow.js";
 import type { HonuaFeatureEditorMessages } from "./types.js";
 declare const HTMLElementBase: typeof HTMLElement;
 /** Detail of the `honua-feature-edit-change` event (redacted snapshot). */
-export interface HonuaFeatureEditChangeDetail {
-    readonly snapshot: HonuaFeatureEditorSnapshot;
+export interface HonuaFeatureEditChangeDetail<T = Record<string, unknown>> {
+    readonly snapshot: HonuaFeatureEditorSnapshot<T>;
 }
 /** Detail of the `honua-feature-edit-commit` event (submit outcome). */
-export interface HonuaFeatureEditCommitDetail {
-    readonly commit: HonuaFeatureEditorCommit;
+export interface HonuaFeatureEditCommitDetail<T = Record<string, unknown>> {
+    readonly commit: HonuaFeatureEditorCommit<T>;
+}
+/** Durable offline conflict choice requested by the editor presentation. */
+export interface HonuaFeatureEditOfflineConflictDetail {
+    readonly choice: HonuaFeatureEditorConflictChoice;
+    readonly offline: HonuaFeatureEditorOfflineState;
 }
 export declare class HonuaFeatureEditorElement<T = Record<string, unknown>> extends HTMLElementBase {
     #private;
@@ -60,6 +66,12 @@ export declare class HonuaFeatureEditorElement<T = Record<string, unknown>> exte
     /** The workflow this editor renders. Setting it re-subscribes and re-renders. */
     get workflow(): HonuaFeatureEditorWorkflow<T> | undefined;
     set workflow(workflow: HonuaFeatureEditorWorkflow<T> | undefined);
+    /** Application shell context assigned and driven by `mountHonuaApplication()`. */
+    get applicationContext(): HonuaApplicationContext<T> | undefined;
+    set applicationContext(context: HonuaApplicationContext<T> | undefined);
+    honuaApplicationContextConnected(context: HonuaApplicationContext<T>): void;
+    honuaApplicationContextChanged(event: HonuaApplicationContextChangeEvent<T>): void;
+    honuaApplicationContextDisconnected(context: HonuaApplicationContext<T>): void;
     /** Equivalent to setting `.workflow`. */
     connect(workflow: HonuaFeatureEditorWorkflow<T>): void;
     /**
@@ -71,7 +83,9 @@ export declare class HonuaFeatureEditorElement<T = Record<string, unknown>> exte
     get selectedFeature(): CanonicalFeature<T> | undefined;
     set selectedFeature(feature: CanonicalFeature<T> | undefined);
     /** The last snapshot rendered. */
-    get snapshot(): HonuaFeatureEditorSnapshot | undefined;
+    get snapshot(): HonuaFeatureEditorSnapshot<T> | undefined;
+    /** Credential-free, transport-free review of the current draft. */
+    preflight(): HonuaFeatureEditorPreflight | undefined;
     attributeChangedCallback(): void;
     connectedCallback(): void;
     disconnectedCallback(): void;

package/web-components/feature-editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-editor.d.ts","sourceRoot":"","sources":["../../../src/web-components/feature-editor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAG7D,OAAO,KAAK,EACV,wBAAwB,EAExB,0BAA0B,EAC1B,0BAA0B,EAC3B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAQ7D,QAAA,MAAM,eAAe,EAAE,OAAO,WAAkF,CAAC;AAEjH,2EAA2E;AAC3E,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,QAAQ,EAAE,0BAA0B,CAAC;CAC/C;AAED,wEAAwE;AACxE,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC;CAC3C;AAQD,qBAAa,yBAAyB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAE,SAAQ,eAAe;;IACzF,WAAkB,kBAAkB,IAAI,MAAM,EAAE,CAE/C;IAiBD,IAAW,QAAQ,IAAI,0BAA0B,CAEhD;IACD,IAAW,QAAQ,CAAC,QAAQ,EAAE,0BAA0B,GAAG,SAAS,EAGnE;IAED,iFAAiF;IACjF,IAAW,QAAQ,IAAI,0BAA0B,CAAC,CAAC,CAAC,GAAG,SAAS,CAE/D;IAED,IAAW,QAAQ,CAAC,QAAQ,EAAE,0BAA0B,CAAC,CAAC,CAAC,GAAG,SAAS,EAYtE;IAeD,yCAAyC;IAClC,OAAO,CAAC,QAAQ,EAAE,0BAA0B,CAAC,CAAC,CAAC,GAAG,IAAI;IAI7D;;;;;OAKG;IACH,IAAW,eAAe,IAAI,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS,CAE5D;IAED,IAAW,eAAe,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS,EAElE;IAED,kCAAkC;IAClC,IAAW,QAAQ,IAAI,0BAA0B,GAAG,SAAS,CAE5D;IAEM,wBAAwB,IAAI,IAAI;IAIhC,iBAAiB,IAAI,IAAI;IAQzB,oBAAoB,IAAI,IAAI;IAgDnC,SAAS,CAAC,MAAM,IAAI,IAAI;CAwZzB;AAED,mFAAmF;AACnF,wBAAgB,wBAAwB,CAAC,QAAQ,wBAA2B,GAAG,IAAI,CAKlF"}
+{"version":3,"file":"feature-editor.d.ts","sourceRoot":"","sources":["../../../src/web-components/feature-editor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EACV,uBAAuB,EACvB,kCAAkC,EAEnC,MAAM,0BAA0B,CAAC;AAGlC,OAAO,KAAK,EACV,wBAAwB,EACxB,gCAAgC,EAChC,8BAA8B,EAC9B,2BAA2B,EAC3B,0BAA0B,EAC1B,0BAA0B,EAC3B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAQ7D,QAAA,MAAM,eAAe,EAAE,OAAO,WAAkF,CAAC;AAEjH,2EAA2E;AAC3E,MAAM,WAAW,4BAA4B,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACvE,QAAQ,CAAC,QAAQ,EAAE,0BAA0B,CAAC,CAAC,CAAC,CAAC;CAClD;AAED,wEAAwE;AACxE,MAAM,WAAW,4BAA4B,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACvE,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC,CAAC,CAAC;CAC9C;AAED,4EAA4E;AAC5E,MAAM,WAAW,qCAAqC;IACpD,QAAQ,CAAC,MAAM,EAAE,gCAAgC,CAAC;IAClD,QAAQ,CAAC,OAAO,EAAE,8BAA8B,CAAC;CAClD;AAQD,qBAAa,yBAAyB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAE,SAAQ,eAAe;;IACzF,WAAkB,kBAAkB,IAAI,MAAM,EAAE,CAE/C;IAkBD,IAAW,QAAQ,IAAI,0BAA0B,CAEhD;IACD,IAAW,QAAQ,CAAC,QAAQ,EAAE,0BAA0B,GAAG,SAAS,EAGnE;IAED,iFAAiF;IACjF,IAAW,QAAQ,IAAI,0BAA0B,CAAC,CAAC,CAAC,GAAG,SAAS,CAE/D;IAED,IAAW,QAAQ,CAAC,QAAQ,EAAE,0BAA0B,CAAC,CAAC,CAAC,GAAG,SAAS,EAYtE;IAgBD,kFAAkF;IAClF,IAAW,kBAAkB,IAAI,uBAAuB,CAAC,CAAC,CAAC,GAAG,SAAS,CAEtE;IAED,IAAW,kBAAkB,CAAC,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAAG,SAAS,EAI5E;IAEM,gCAAgC,CAAC,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAAG,IAAI;IAI3E,8BAA8B,CAAC,KAAK,EAAE,kCAAkC,CAAC,CAAC,CAAC,GAAG,IAAI;IAKlF,mCAAmC,CAAC,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAAG,IAAI;IAIrF,yCAAyC;IAClC,OAAO,CAAC,QAAQ,EAAE,0BAA0B,CAAC,CAAC,CAAC,GAAG,IAAI;IAI7D;;;;;OAKG;IACH,IAAW,eAAe,IAAI,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS,CAE5D;IAED,IAAW,eAAe,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS,EAOlE;IAED,kCAAkC;IAClC,IAAW,QAAQ,IAAI,0BAA0B,CAAC,CAAC,CAAC,GAAG,SAAS,CAE/D;IAED,mEAAmE;IAC5D,SAAS,IAAI,2BAA2B,GAAG,SAAS;IAIpD,wBAAwB,IAAI,IAAI;IAIhC,iBAAiB,IAAI,IAAI;IAQzB,oBAAoB,IAAI,IAAI;IAgDnC,SAAS,CAAC,MAAM,IAAI,IAAI;CA0fzB;AAED,mFAAmF;AACnF,wBAAgB,wBAAwB,CAAC,QAAQ,wBAA2B,GAAG,IAAI,CAKlF"}