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

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

@@ -0,0 +1,194 @@
+/**
+ * The app-platform sketch default for `<honua-feature-editor>` (issue #680,
+ * REQ-002): a terra-draw-backed geometry adapter that stays bound across the
+ * editor's draft lifecycle.
+ *
+ * The SDK already ships the renderer-neutral sketch/snapping seam
+ * (`bindTerraDrawSketch`, `createTerraDrawSketch`, `createTerraDrawSnapping`,
+ * `terraDrawSketchToolCapabilities` on `@honua/sdk-js/runtime`). What
+ * app-platform adds here is *lifecycle composition*: a
+ * {@link HonuaFeatureEditorWorkflow} builds a fresh contract sketch workflow
+ * every time a draft opens, so a one-shot binding would silently stop driving
+ * the editor after the first submit. {@link bindEditorSketch} watches the
+ * workflow and re-binds terra-draw to each new draft's model, and reports
+ * terra-draw's true tool support (which upgrades `rectangle` / `circle` from
+ * the contract's renderer-support-required defaults) into the workflow so the
+ * editor's tool buttons are truthful.
+ *
+ * terra-draw itself stays an optional peer: {@link bindEditorSketch} takes a
+ * duck-typed instance the app already constructed, and only
+ * {@link createTerraDrawEditorSketch} — the one-call default — pulls the peer
+ * in, through the runtime module's own lazy `import()`.
+ *
+ * @module
+ */
+import { resolveSnappingConfig } from "../contract/edit-snapping.js";
+import { bindTerraDrawSketch, createTerraDrawSketch, terraDrawSketchToolCapabilities, } from "../runtime/terra-draw-sketch.js";
+/**
+ * Binds an already-constructed terra-draw instance to an editor workflow, and
+ * keeps it bound as drafts open and close.
+ *
+ * Also reports terra-draw's real tool support into the workflow, so the
+ * editor's `rectangle` / `circle` buttons become enabled instead of showing
+ * the contract's "requires renderer support" reason.
+ */
+export function bindEditorSketch(draw, options) {
+    return createAdapter(options, () => draw);
+}
+/**
+ * Snapping options to hand terra-draw for an editor workflow.
+ *
+ * terra-draw resolves `snapping.toCustom` once per mode, at construction, and
+ * `createTerraDrawSnapping` captures the `model` it is given — but the editor
+ * builds a *new* contract sketch model for every draft. Passing the model
+ * directly would pin snapping to the first draft forever, so
+ * `setSnapping(...)` on any later draft would silently do nothing.
+ *
+ * This returns a stable options object whose `model` is a thin live view that
+ * resolves the workflow's *current* model on each pointer event, falling back
+ * to `config` (or disabled snapping) while no draft is open.
+ *
+ * Use it when constructing terra-draw yourself alongside
+ * {@link bindEditorSketch}; {@link createTerraDrawEditorSketch} applies it for
+ * you.
+ */
+export function editorSnappingOptions(workflow, snapping) {
+    const fallback = resolveSnappingConfig(snapping.config ?? { enabled: false });
+    const liveModel = {
+        snappingConfig: () => workflow.sketchModel()?.snappingConfig() ?? fallback,
+    };
+    // Deliberately no `config`: `createTerraDrawSnapping` only consults the model
+    // when `config` is absent, which is exactly the live path we want.
+    return { index: snapping.index, model: liveModel };
+}
+/**
+ * The app-platform terra-draw default: constructs terra-draw for a MapLibre
+ * map (pulling the optional `terra-draw` peers lazily through the runtime
+ * module), wires SDK snapping, and binds it to the editor workflow for the
+ * lifetime of the adapter.
+ *
+ * @example
+ * ```ts
+ * const workflow = createFeatureEditorWorkflow({ source });
+ * const sketch = await createTerraDrawEditorSketch(map, { workflow });
+ * editor.workflow = workflow;   // <honua-feature-editor>
+ * ```
+ */
+export async function createTerraDrawEditorSketch(map, options) {
+    const { workflow } = options;
+    workflow.configureSketchTools(terraDrawSketchToolCapabilities(options.modes));
+    const model = workflow.sketchModel() ?? bootstrapModel(workflow);
+    const snapping = options.snapping ? editorSnappingOptions(workflow, options.snapping) : undefined;
+    const controller = await createTerraDrawSketch(map, {
+        model,
+        ...bindPassThrough(options),
+        ...(snapping ? { snapping } : {}),
+    });
+    // The controller's own binding covers whichever model existed at
+    // construction; the adapter owns every binding from here on.
+    controller.remove();
+    const adapter = createAdapter(options, () => controller.draw);
+    return {
+        ...adapter,
+        setTool: (tool) => adapter.setTool(tool),
+        select: () => adapter.select(),
+        cancel: () => adapter.cancel(),
+        undo: () => adapter.undo(),
+        redo: () => adapter.redo(),
+        syncFromModel: () => adapter.syncFromModel(),
+        ready: () => adapter.ready(),
+        remove: () => adapter.remove(),
+        stop() {
+            adapter.remove();
+            controller.stop();
+        },
+    };
+}
+// ── shared adapter ───────────────────────────────────────────────────────
+function createAdapter(options, drawOf) {
+    const { workflow } = options;
+    // Report terra-draw's real tool support so the editor's rectangle / circle
+    // buttons stop showing the contract's "requires renderer support" reason.
+    workflow.configureSketchTools(terraDrawSketchToolCapabilities(options.modes));
+    let handle;
+    let bound;
+    let pending = Promise.resolve();
+    let removed = false;
+    const rebind = () => {
+        if (removed)
+            return;
+        const model = workflow.sketchModel();
+        if (model === bound)
+            return;
+        handle?.remove();
+        handle = undefined;
+        bound = model;
+        if (!model)
+            return;
+        handle = bindTerraDrawSketch(drawOf(), { model, ...bindPassThrough(options) });
+    };
+    const schedule = () => {
+        pending = pending.then(() => {
+            rebind();
+        });
+    };
+    const subscription = workflow.subscribe(schedule);
+    rebind();
+    return {
+        setTool(tool) {
+            if (handle)
+                return handle.setTool(tool);
+            return workflow.startSketch(tool);
+        },
+        select() {
+            handle?.select();
+        },
+        cancel() {
+            handle?.cancel();
+        },
+        undo() {
+            return handle ? handle.undo() : workflow.undo();
+        },
+        redo() {
+            return handle ? handle.redo() : workflow.redo();
+        },
+        syncFromModel() {
+            return handle?.syncFromModel() ?? false;
+        },
+        ready() {
+            return pending;
+        },
+        remove() {
+            removed = true;
+            subscription.remove();
+            handle?.remove();
+            handle = undefined;
+            bound = undefined;
+        },
+    };
+}
+function bindPassThrough(options) {
+    return {
+        ...(options.transformGeometry ? { transformGeometry: options.transformGeometry } : {}),
+        ...(options.restoreGeometry ? { restoreGeometry: options.restoreGeometry } : {}),
+        ...(options.featureFilter ? { featureFilter: options.featureFilter } : {}),
+        ...(options.toolForMode ? { toolForMode: options.toolForMode } : {}),
+        ...(options.onFinish ? { onFinish: options.onFinish } : {}),
+        ...(options.onDelete ? { onDelete: options.onDelete } : {}),
+    };
+}
+/**
+ * terra-draw needs a model at construction time, but an editor may have no
+ * draft open yet. Opening a throwaway create draft yields a real contract
+ * sketch workflow to construct against; the adapter re-binds to whatever draft
+ * the host opens next.
+ */
+function bootstrapModel(workflow) {
+    workflow.begin("create");
+    const model = workflow.sketchModel();
+    if (!model) {
+        throw new Error("createTerraDrawEditorSketch: the editor workflow could not open a draft to bind terra-draw against " +
+            "(the source does not support editing). Bind a sketch adapter only to an editable source.");
+    }
+    return model;
+}

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

@@ -0,0 +1,286 @@
+/**
+ * Host-facing edit workflow behind `<honua-feature-editor>` (issue #680).
+ *
+ * This is the composition layer: it owns a public contract
+ * {@link EditSketchWorkflowModel} (which itself owns the edit session, undo /
+ * redo, snapping, attachment staging, optimistic hooks, and the single
+ * `applyEdits` call) and adds only what an operational editing UI needs on top
+ * and the protocol layer deliberately does not model:
+ *
+ * - **Draft identity.** A draft is scoped to `source` + feature id + the
+ *   concurrency token observed when it opened, so an unrelated realtime change
+ *   can be recognised and ignored without disturbing the form
+ *   ({@link HonuaFeatureEditorWorkflow.applyExternalChange}, REQ-005).
+ * - **Subtype-aware pre-transport validation.** Subtype overrides change the
+ *   valid choices per field. Rather than duplicating the contract validator,
+ *   {@link HonuaFeatureEditorWorkflow.validate} builds a throwaway
+ *   `createEditSession` over the *subtype-resolved* field list and runs the
+ *   contract's own `validate()` against it, merging the result with the live
+ *   model's session-level verdict. An invalid draft is rejected with
+ *   `transported: false` — nothing reaches the wire.
+ * - **An explicit conflict gate.** A version/etag/precondition failure (or a
+ *   divergent external change) parks the draft in `"conflict"`; `submit()`
+ *   refuses to retransport until {@link HonuaFeatureEditorWorkflow.resolveConflict}
+ *   records a decision (REQ-004 / REQ-005).
+ * - **Redacted state.** Snapshots and events describe staged attachments but
+ *   never carry the payload — a `Blob` or a (possibly credential-bearing)
+ *   string URL stays inside the edit session.
+ *
+ * No protocol adapter is imported and no status is ever optimistic about a
+ * rejected edit: every non-`"succeeded"` submit result maps to
+ * `"rejected"` / `"conflict"` / `"unsupported"` / `"cancelled"`, never
+ * `"committed"`.
+ *
+ * @module
+ */
+import { type EditWorkflowFailureKind, type EditWorkflowField, type EditWorkflowMetadataOptions, type EditWorkflowOperation, type EditWorkflowOptimisticHooks, type EditWorkflowValidationResult } from "../contract/edit-session.js";
+import { type EditSketchTool, type EditSketchToolCapability, type EditSketchToolCapabilityInput, type EditSketchUndoSnapshot, type EditSketchWorkflowModel } from "../contract/edit-sketch.js";
+import type { SnappingConfig } from "../contract/edit-snapping.js";
+import type { CanonicalFeature, FeatureId, Source, SourceId } from "../contract/types.js";
+import { type HonuaEditorAttachmentDraft, type HonuaEditorFormModel, type HonuaEditorOperation, type HonuaEditorOperationAvailability, type HonuaEditorOperationOverrides, type HonuaEditorSubtypeConfig } from "./feature-editor-model.js";
+/** Lifecycle state of the editor. Never `"committed"` for a rejected edit. */
+export type HonuaFeatureEditorStatus = "idle" | "draft" | "submitting" | "committed" | "rejected" | "conflict" | "cancelled" | "unsupported";
+/** Identity a draft is scoped to until it is accepted. */
+export interface HonuaFeatureEditorIdentity {
+    readonly sourceId: SourceId;
+    readonly featureId?: FeatureId;
+    /** Concurrency token observed when the draft opened, when the source has one. */
+    readonly version?: unknown;
+    readonly versionField?: string;
+}
+/** A failure surfaced to the UI, normalized from the contract's own failure list. */
+export interface HonuaFeatureEditorFailure {
+    readonly kind: EditWorkflowFailureKind;
+    readonly operation: EditWorkflowOperation;
+    readonly code?: number;
+    readonly description: string;
+}
+/** How a conflicting draft may be resolved. */
+export type HonuaFeatureEditorConflictChoice = "keep-mine" | "discard-mine" | "reload";
+/** An unresolved conflict. `submit()` refuses to transport while this is set. */
+export interface HonuaFeatureEditorConflict {
+    readonly reason: string;
+    readonly versionField?: string;
+    /** Token the draft carries. */
+    readonly mine?: unknown;
+    /** Token observed on the server / in the external change, when known. */
+    readonly theirs?: unknown;
+    readonly choices: readonly HonuaFeatureEditorConflictChoice[];
+}
+/** Geometry / sketch state, mirrored from the contract sketch workflow. */
+export interface HonuaFeatureEditorSketchState {
+    readonly status: "idle" | "sketching" | "ready" | "unsupported";
+    readonly activeTool?: EditSketchTool;
+    readonly tools: readonly EditSketchToolCapability[];
+    readonly geometry: Record<string, unknown> | null | undefined;
+    readonly snapping: Pick<SnappingConfig, "enabled" | "tolerance">;
+}
+/** Everything the editor UI renders. Carries no attachment payloads. */
+export interface HonuaFeatureEditorSnapshot {
+    readonly status: HonuaFeatureEditorStatus;
+    readonly operation?: HonuaEditorOperation;
+    readonly identity?: HonuaFeatureEditorIdentity;
+    readonly operations: readonly HonuaEditorOperationAvailability[];
+    readonly form?: HonuaEditorFormModel;
+    readonly sketch?: HonuaFeatureEditorSketchState;
+    readonly undo: EditSketchUndoSnapshot;
+    readonly attachments: readonly HonuaEditorAttachmentDraft[];
+    readonly attachmentsSupported: boolean;
+    readonly failures: readonly HonuaFeatureEditorFailure[];
+    readonly conflict?: HonuaFeatureEditorConflict;
+    readonly dirty: boolean;
+    readonly busy: boolean;
+    readonly message: string;
+    readonly committedFeatureId?: FeatureId;
+}
+/** Outcome of a `submit()` / `retry()`. `transported` is false for pre-flight rejections. */
+export interface HonuaFeatureEditorCommit {
+    readonly status: HonuaFeatureEditorStatus;
+    readonly operation: HonuaEditorOperation;
+    readonly transported: boolean;
+    readonly committedFeatureId?: FeatureId;
+    readonly failures: readonly HonuaFeatureEditorFailure[];
+    readonly attachments: readonly HonuaEditorAttachmentDraft[];
+    readonly snapshot: HonuaFeatureEditorSnapshot;
+    /**
+     * True when this submit no longer owned the workflow by the time the
+     * transport settled — a newer draft had already been opened (or the draft was
+     * cancelled and replaced). The workflow state was left entirely to the newer
+     * draft, so `status` is reported as `"cancelled"` and `snapshot` describes the
+     * *current* draft, not this one. The server outcome for the superseded edit is
+     * in `failures` (empty means the service reported no failure), but the
+     * workflow makes no claim about it.
+     */
+    readonly superseded?: boolean;
+}
+/** Result of reconciling one external (realtime) feature change. */
+export type HonuaFeatureEditorExternalChangeOutcome = "ignored" | "reconciled" | "conflict";
+export interface HonuaFeatureEditorOptions<T = Record<string, unknown>> {
+    /** Editable source. Only the public `Source` contract is used. */
+    readonly source: Source<T>;
+    /**
+     * Field / domain / primary-key / conflict metadata. Defaults to the source's
+     * public schema, with coded-value and range domains projected across (see
+     * `editorFieldsFromSchema`).
+     */
+    readonly metadata?: EditWorkflowMetadataOptions;
+    /** Subtype configuration; drives per-subtype choices and overrides. */
+    readonly subtypes?: HonuaEditorSubtypeConfig;
+    /** Per-operation host denials (e.g. a service's `deleteEnabled: false`). Deny-only. */
+    readonly operations?: HonuaEditorOperationOverrides;
+    /** Sketch tool capabilities; a sketch adapter (e.g. terra-draw) supplies its own. */
+    readonly sketchTools?: Partial<Record<EditSketchTool, EditSketchToolCapabilityInput>>;
+    readonly snapping?: Partial<SnappingConfig>;
+    readonly rollbackOnFailure?: boolean;
+    /** Optimistic apply/rollback/commit hooks, passed straight to the edit session. */
+    readonly optimistic?: EditWorkflowOptimisticHooks<T>;
+}
+type EditorListener = (snapshot: HonuaFeatureEditorSnapshot) => void;
+export declare class HonuaFeatureEditorWorkflow<T = Record<string, unknown>> {
+    #private;
+    readonly source: Source<T>;
+    constructor(options: HonuaFeatureEditorOptions<T>);
+    /** Subscribes to snapshot changes. Mirrors the kit's `{ remove() }` idiom. */
+    subscribe(listener: EditorListener): {
+        remove(): void;
+    };
+    /** The underlying contract sketch workflow, for a sketch adapter to bind to. */
+    sketchModel(): EditSketchWorkflowModel<T> | undefined;
+    /**
+     * Subtype-resolved field metadata for the open draft, or — before one is
+     * opened — for the recorded selection. Resolving against the selection
+     * matters: a subtype's overrides can flip a field's editability, so using the
+     * default subtype here would report the wrong `update` / `delete`
+     * availability for the feature the host actually selected.
+     */
+    fields(): readonly EditWorkflowField[];
+    /** Truthful per-operation availability for the current source and selection. */
+    operations(): readonly HonuaEditorOperationAvailability[];
+    /**
+     * Merged pre-transport validation: the contract validator run over the
+     * subtype-resolved field list, unioned with the live session's own
+     * session-level verdict (capability, identity, attachment support).
+     */
+    validate(): EditWorkflowValidationResult;
+    /** Current UI state. Never contains an attachment payload. */
+    snapshot(): HonuaFeatureEditorSnapshot;
+    /**
+     * Records the host's current selection (table row, map click, search result)
+     * so `update` / `delete` availability reflects it before a draft is opened.
+     *
+     * Ignored while a draft is open — an open draft owns its identity. A
+     * *committed* draft is the one exception: it is finished, and the host's
+     * re-read of the record it just wrote carries the only fresh concurrency
+     * token there is. Refusing it would leave `selection()` on the pre-commit
+     * feature, so the next `update` would reopen on a stale token the service has
+     * to reject. Accepting it closes the finished draft without touching the
+     * committed status or message — nothing about the commit is retracted.
+     */
+    setSelection(feature: CanonicalFeature<T> | undefined): HonuaFeatureEditorSnapshot;
+    /** The host selection `update` / `delete` drafts open on. */
+    selection(): CanonicalFeature<T> | undefined;
+    /**
+     * Opens a draft, defaulting to the recorded selection. When the requested
+     * operation is not truthfully available the draft is refused and the reason
+     * recorded — never silently downgraded.
+     */
+    begin(operation: HonuaEditorOperation, feature?: CanonicalFeature<T>): HonuaFeatureEditorSnapshot;
+    /** Discards the draft and aborts any in-flight submit. */
+    cancel(): HonuaFeatureEditorSnapshot;
+    /** Reverts the draft to the feature it opened on, keeping the draft open. */
+    discardChanges(): HonuaFeatureEditorSnapshot;
+    /**
+     * Records raw control input for a field, coerced to the field's own type
+     * (coded values resolve back to the domain code's type, so a numeric code
+     * never reaches transport as a string).
+     */
+    setValue(name: string, raw: string | boolean | null): HonuaFeatureEditorSnapshot;
+    /** Records several already-typed attribute values at once. */
+    setValues(values: Readonly<Record<string, unknown>>): HonuaFeatureEditorSnapshot;
+    /** Arms a sketch tool. Unsupported tools report their reason rather than throwing. */
+    startSketch(tool: EditSketchTool): EditSketchToolCapability;
+    /** Applies a geometry through the sketch workflow (undoable). */
+    setGeometry(tool: EditSketchTool, geometry: Record<string, unknown> | null): HonuaFeatureEditorSnapshot;
+    undo(): boolean;
+    redo(): boolean;
+    /**
+     * Stages an attachment. The payload is handed straight to the edit session;
+     * only redacted metadata enters the snapshot.
+     */
+    stageAttachment(attachment: Blob | File | string, options?: {
+        name?: string;
+        contentType?: string;
+        parentId?: FeatureId;
+    }): HonuaFeatureEditorSnapshot;
+    /** Stages an attachment deletion. */
+    stageAttachmentDelete(attachmentIds: readonly FeatureId[], options?: {
+        parentId?: FeatureId;
+    }): HonuaFeatureEditorSnapshot;
+    /**
+     * Replaces the sketch tool capabilities (a sketch adapter such as terra-draw
+     * calls this so `rectangle` / `circle` become truthfully supported). An open
+     * draft is rebuilt in place, preserving values, geometry, and staged
+     * attachments; undo history restarts because tool support is a new baseline.
+     */
+    configureSketchTools(tools: Partial<Record<EditSketchTool, EditSketchToolCapabilityInput>>): HonuaFeatureEditorSnapshot;
+    /**
+     * Validates, then applies the draft through the contract edit session.
+     *
+     * Refuses to transport when the draft is invalid or an unresolved conflict is
+     * parked (`transported: false`). Every non-success result maps to a
+     * rejected / conflict / unsupported state — never `"committed"`.
+     */
+    submit(): Promise<HonuaFeatureEditorCommit>;
+    /** Re-submits after a rejection (or after a resolved conflict). */
+    retry(): Promise<HonuaFeatureEditorCommit>;
+    /**
+     * Records an explicit decision for a parked conflict.
+     *
+     * - `"keep-mine"` keeps the draft and, when the source's concurrency token
+     *   is known, adopts the observed server token so the retry can pass the
+     *   service's precondition (an explicit overwrite).
+     * - `"discard-mine"` reverts the draft to the feature it opened on.
+     * - `"reload"` closes the draft; the host is expected to reopen it on fresh
+     *   server state.
+     */
+    resolveConflict(choice: HonuaFeatureEditorConflictChoice): HonuaFeatureEditorSnapshot;
+    /**
+     * Adopts the service's post-write concurrency token into a draft that stays
+     * open on purpose — the partial outcome where the feature edit applied and
+     * only an attachment was refused (issue #680).
+     *
+     * A protocol like GeoServices returns nothing but `objectId` and `success`
+     * from `applyEdits`, so the new token exists only in the host's re-read of the
+     * record. Feeding that back through {@link setValue} would read as a user
+     * revision and clear the rejected status and the recorded failures — erasing
+     * exactly the truth about what the service refused. This does not: status,
+     * failures, and staged-attachment outcomes all survive, so {@link retry}
+     * re-transports the same recovery against the version now on file instead of
+     * the one the accepted write already consumed.
+     *
+     * The draft's own baseline is deliberately left alone: it is still the values
+     * this draft opened on, and moving it could make an unrelated server-assigned
+     * field look like a read-only edit the user made.
+     *
+     * Returns `false` — changing nothing — when no draft is open, when the record
+     * is a different feature, or when the source publishes no concurrency token.
+     */
+    adoptServerState(feature: CanonicalFeature<T>): boolean;
+    /**
+     * Reconciles one externally changed feature against the open draft (REQ-005).
+     *
+     * - A change to a different feature is `"ignored"`: no state changes and no
+     *   listener runs, so selection, unsaved values, focus, and geometry survive
+     *   unrelated realtime traffic untouched.
+     * - A change to the drafted feature carrying the same concurrency token is
+     *   `"reconciled"`: the baseline adopts the server values, and only fields the
+     *   user has *not* touched adopt the new values.
+     * - A change carrying a different token is a `"conflict"`: the draft is
+     *   untouched and parked until {@link resolveConflict} records a decision.
+     */
+    applyExternalChange(feature: CanonicalFeature<T>): HonuaFeatureEditorExternalChangeOutcome;
+}
+/** Creates a {@link HonuaFeatureEditorWorkflow}. */
+export declare function createFeatureEditorWorkflow<T = Record<string, unknown>>(options: HonuaFeatureEditorOptions<T>): HonuaFeatureEditorWorkflow<T>;
+export {};
+//# sourceMappingURL=feature-editor-workflow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature-editor-workflow.d.ts","sourceRoot":"","sources":["../../../src/web-components/feature-editor-workflow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,EAEL,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,KAAK,2BAA2B,EAChC,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAGhC,KAAK,4BAA4B,EAElC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,EAClC,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAE7B,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAC1F,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,gCAAgC,EACrC,KAAK,6BAA6B,EAClC,KAAK,wBAAwB,EAS9B,MAAM,2BAA2B,CAAC;AAEnC,8EAA8E;AAC9E,MAAM,MAAM,wBAAwB,GAChC,MAAM,GACN,OAAO,GACP,YAAY,GACZ,WAAW,GACX,UAAU,GACV,UAAU,GACV,WAAW,GACX,aAAa,CAAC;AAElB,0DAA0D;AAC1D,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,qFAAqF;AACrF,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,qBAAqB,CAAC;IAC1C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,+CAA+C;AAC/C,MAAM,MAAM,gCAAgC,GAAG,WAAW,GAAG,cAAc,GAAG,QAAQ,CAAC;AAEvF,iFAAiF;AACjF,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,+BAA+B;IAC/B,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,yEAAyE;IACzE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,gCAAgC,EAAE,CAAC;CAC/D;AAED,2EAA2E;AAC3E,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO,GAAG,aAAa,CAAC;IAChE,QAAQ,CAAC,UAAU,CAAC,EAAE,cAAc,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;IAC9D,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,cAAc,EAAE,SAAS,GAAG,WAAW,CAAC,CAAC;CAClE;AAED,wEAAwE;AACxE,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC;IAC1C,QAAQ,CAAC,SAAS,CAAC,EAAE,oBAAoB,CAAC;IAC1C,QAAQ,CAAC,QAAQ,CAAC,EAAE,0BAA0B,CAAC;IAC/C,QAAQ,CAAC,UAAU,EAAE,SAAS,gCAAgC,EAAE,CAAC;IACjE,QAAQ,CAAC,IAAI,CAAC,EAAE,oBAAoB,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,6BAA6B,CAAC;IAChD,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IACtC,QAAQ,CAAC,WAAW,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAC5D,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,SAAS,yBAAyB,EAAE,CAAC;IACxD,QAAQ,CAAC,QAAQ,CAAC,EAAE,0BAA0B,CAAC;IAC/C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,CAAC;CACzC;AAED,6FAA6F;AAC7F,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC;IAC1C,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,SAAS,yBAAyB,EAAE,CAAC;IACxD,QAAQ,CAAC,WAAW,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAC5D,QAAQ,CAAC,QAAQ,EAAE,0BAA0B,CAAC;IAC9C;;;;;;;;OAQG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,oEAAoE;AACpE,MAAM,MAAM,uCAAuC,GAAG,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;AAE5F,MAAM,WAAW,yBAAyB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACpE,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,2BAA2B,CAAC;IAChD,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,CAAC,EAAE,wBAAwB,CAAC;IAC7C,uFAAuF;IACvF,QAAQ,CAAC,UAAU,CAAC,EAAE,6BAA6B,CAAC;IACpD,qFAAqF;IACrF,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,6BAA6B,CAAC,CAAC,CAAC;IACtF,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;IAC5C,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC,mFAAmF;IACnF,QAAQ,CAAC,UAAU,CAAC,EAAE,2BAA2B,CAAC,CAAC,CAAC,CAAC;CACtD;AAED,KAAK,cAAc,GAAG,CAAC,QAAQ,EAAE,0BAA0B,KAAK,IAAI,CAAC;AAMrE,qBAAa,0BAA0B,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;IACjE,SAAgB,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;gBA2Bf,OAAO,EAAE,yBAAyB,CAAC,CAAC,CAAC;IAUxD,8EAA8E;IACvE,SAAS,CAAC,QAAQ,EAAE,cAAc,GAAG;QAAE,MAAM,IAAI,IAAI,CAAA;KAAE;IAW9D,gFAAgF;IACzE,WAAW,IAAI,uBAAuB,CAAC,CAAC,CAAC,GAAG,SAAS;IAI5D;;;;;;OAMG;IACI,MAAM,IAAI,SAAS,iBAAiB,EAAE;IAI7C,gFAAgF;IACzE,UAAU,IAAI,SAAS,gCAAgC,EAAE;IAIhE;;;;OAIG;IACI,QAAQ,IAAI,4BAA4B;IAiB/C,8DAA8D;IACvD,QAAQ,IAAI,0BAA0B;IA4C7C;;;;;;;;;;;OAWG;IACI,YAAY,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,0BAA0B;IAazF,6DAA6D;IACtD,SAAS,IAAI,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS;IAInD;;;;OAIG;IACI,KAAK,CAAC,SAAS,EAAE,oBAAoB,EAAE,OAAO,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,0BAA0B;IA0CxG,0DAA0D;IACnD,MAAM,IAAI,0BAA0B;IAe3C,6EAA6E;IACtE,cAAc,IAAI,0BAA0B;IAYnD;;;;OAIG;IACI,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,0BAA0B;IASvF,8DAA8D;IACvD,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,0BAA0B;IAUvF,sFAAsF;IAC/E,WAAW,CAAC,IAAI,EAAE,cAAc,GAAG,wBAAwB;IAYlE,iEAAiE;IAC1D,WAAW,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,0BAA0B;IAQvG,IAAI,IAAI,OAAO;IASf,IAAI,IAAI,OAAO;IAWtB;;;OAGG;IACI,eAAe,CACpB,UAAU,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,EAChC,OAAO,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;KAAO,GAC1E,0BAA0B;IAS7B,qCAAqC;IAC9B,qBAAqB,CAC1B,aAAa,EAAE,SAAS,SAAS,EAAE,EACnC,OAAO,GAAE;QAAE,QAAQ,CAAC,EAAE,SAAS,CAAA;KAAO,GACrC,0BAA0B;IAW7B;;;;;OAKG;IACI,oBAAoB,CACzB,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,6BAA6B,CAAC,CAAC,GACpE,0BAA0B;IAmB7B;;;;;;OAMG;IACU,MAAM,IAAI,OAAO,CAAC,wBAAwB,CAAC;IA+ExD,mEAAmE;IACtD,KAAK,IAAI,OAAO,CAAC,wBAAwB,CAAC;IAUvD;;;;;;;;;OASG;IACI,eAAe,CAAC,MAAM,EAAE,gCAAgC,GAAG,0BAA0B;IA+B5F;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,OAAO;IAiB9D;;;;;;;;;;;OAWG;IACI,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,uCAAuC;CAgNlG;AAED,oDAAoD;AACpD,wBAAgB,2BAA2B,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrE,OAAO,EAAE,yBAAyB,CAAC,CAAC,CAAC,GACpC,0BAA0B,CAAC,CAAC,CAAC,CAE/B"}