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

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

@@ -0,0 +1,438 @@
+/**
+ * DOM-free presentation model behind `<honua-feature-editor>` — the
+ * production-tier capability-aware editing surface (issue #680, parent epic
+ * #678).
+ *
+ * Everything here is a *derivation* over the public contract editing
+ * primitives (`EditWorkflowField` / `EditFieldDomain` /
+ * `EditWorkflowCapabilitySummary` / `EditWorkflowValidationResult` from
+ * `@honua/sdk-js/contract`) plus the public source descriptor. No protocol
+ * adapter is imported, no service field name is hard-coded, and no transport
+ * happens: this module turns metadata into renderable controls, turns raw
+ * control input back into typed attribute values, and answers "which
+ * operations are truthfully available right now, and why not".
+ *
+ * Three things the protocol layer deliberately does not model, derived here
+ * because they are presentation concerns:
+ *
+ * 1. **Coded-value / range domains from native schema.** The contract's
+ *    `resolveEditWorkflowMetadata` carries `name`/`type`/`length`/`nullable`/
+ *    `editable`/`defaultValue` across from `SourceSchema.fields` but not the
+ *    native `domain` block. {@link editorFieldsFromSchema} closes that gap
+ *    over a structural (adapter-free) field shape so the contract's own
+ *    `validate()` rejects out-of-domain values *before* transport.
+ * 2. **Subtypes.** There is no subtype primitive in the contract. A subtype is
+ *    modeled here as a coded-value domain on one field plus per-subtype field
+ *    overrides ({@link HonuaEditorSubtypeConfig}); {@link resolveEditorFields}
+ *    folds the active subtype's overrides into the field list handed to the
+ *    edit session, so switching subtype changes the valid choices *and* what
+ *    the contract validator accepts.
+ * 3. **Per-operation availability.** The contract exposes one coarse
+ *    `applyEdits` capability. {@link resolveEditorOperations} splits it into
+ *    truthful per-operation state, folding in the capability profile's
+ *    `authorization-required` / `authorization-denied` / `policy-disabled`
+ *    verdicts, structural facts (an update or delete needs a feature
+ *    identity), and host-supplied per-operation denials. It only ever
+ *    *narrows* — a host override can never grant an operation the source does
+ *    not support (fail closed).
+ *
+ * @module
+ */
+/**
+ * Projects public schema fields onto contract {@link EditWorkflowField}s,
+ * including the coded-value / range domain the contract's own schema
+ * projection drops. Feed the result to `createEditSession`/
+ * `createEditSketchWorkflow` as `metadata.fields` so domain violations fail
+ * validation before any transport happens (REQ-001).
+ */
+export function editorFieldsFromSchema(fields) {
+    return (fields ?? []).map((field) => {
+        const domain = editorDomainFromSchema(field.domain);
+        return {
+            name: field.name,
+            ...(field.type !== undefined ? { type: field.type } : {}),
+            ...(field.alias !== undefined ? { alias: field.alias } : {}),
+            ...(field.length !== undefined ? { length: field.length } : {}),
+            ...(field.nullable !== undefined ? { nullable: field.nullable } : {}),
+            ...(field.editable !== undefined ? { editable: field.editable } : {}),
+            ...(field.defaultValue !== undefined ? { defaultValue: field.defaultValue } : {}),
+            ...(domain ? { domain } : {}),
+        };
+    });
+}
+/** Normalizes a native domain block to the contract's {@link EditFieldDomain}. */
+export function editorDomainFromSchema(domain) {
+    if (!domain)
+        return undefined;
+    const type = (domain.type ?? "").toLowerCase();
+    if (type === "codedvalue" || type === "coded-value" || type === "coded_value" || domain.codedValues) {
+        const codedValues = (domain.codedValues ?? []).map((coded) => ({ name: coded.name ?? String(coded.code), code: coded.code }));
+        if (codedValues.length === 0)
+            return undefined;
+        return { type: "coded-value", ...(domain.name ? { name: domain.name } : {}), codedValues };
+    }
+    if (type === "range" || domain.range) {
+        const min = Number(domain.range?.[0]);
+        const max = Number(domain.range?.[1]);
+        if (!Number.isFinite(min) || !Number.isFinite(max))
+            return undefined;
+        return { type: "range", ...(domain.name ? { name: domain.name } : {}), range: [min, max] };
+    }
+    return undefined;
+}
+/** The subtype in effect for a set of attribute values, if any. */
+export function resolveActiveEditorSubtype(config, values) {
+    if (!config)
+        return undefined;
+    const raw = values[config.field];
+    const code = raw === undefined || raw === null || raw === "" ? config.defaultCode : raw;
+    if (code === undefined)
+        return undefined;
+    return config.subtypes.find((subtype) => sameCode(subtype.code, code));
+}
+/**
+ * Folds subtype state into the field list handed to the edit session: the
+ * subtype field gains a coded-value domain built from the configured
+ * subtypes, and the active subtype's per-field overrides (domain, required,
+ * editable, default, hidden) are applied on top of the base metadata.
+ *
+ * Because the result is what `createEditSession`'s `metadata.fields` receives,
+ * a subtype change immediately changes both the rendered choices and what the
+ * contract validator accepts — an invalid combination is rejected before
+ * transport (REQ-001).
+ */
+export function resolveEditorFields(fields, config, values) {
+    if (!config)
+        return fields;
+    const active = resolveActiveEditorSubtype(config, values);
+    const subtypeDomain = {
+        type: "coded-value",
+        codedValues: config.subtypes.map((subtype) => ({ name: subtype.name, code: subtype.code })),
+    };
+    const known = new Set(fields.map((field) => field.name));
+    const resolved = fields.map((field) => {
+        const base = field.name === config.field ? { ...field, domain: subtypeDomain, required: true } : { ...field };
+        return applySubtypeOverride(base, active?.fieldOverrides?.[field.name]);
+    });
+    // A subtype field absent from the source schema still needs a control and a
+    // domain, otherwise a create draft could never pick a subtype at all.
+    if (!known.has(config.field)) {
+        resolved.unshift(applySubtypeOverride({ name: config.field, type: subtypeCodeType(config), domain: subtypeDomain, required: true }, active?.fieldOverrides?.[config.field]));
+    }
+    return resolved;
+}
+function applySubtypeOverride(field, override) {
+    if (!override)
+        return field;
+    const next = { ...field };
+    if (override.domain === null)
+        delete next.domain;
+    else if (override.domain !== undefined)
+        next.domain = override.domain;
+    if (override.editable !== undefined)
+        next.editable = override.editable;
+    if (override.defaultValue !== undefined)
+        next.defaultValue = override.defaultValue;
+    if (override.hidden === true) {
+        next.required = false;
+        next.nullable = true;
+    }
+    else if (override.required !== undefined) {
+        next.required = override.required;
+    }
+    return next;
+}
+function subtypeCodeType(config) {
+    return config.subtypes.every((subtype) => typeof subtype.code === "number") ? "integer" : "string";
+}
+/** Field names the active subtype hides from the form. */
+export function hiddenEditorFieldNames(config, values) {
+    const active = resolveActiveEditorSubtype(config, values);
+    const hidden = new Set();
+    for (const [name, override] of Object.entries(active?.fieldOverrides ?? {})) {
+        if (override.hidden === true)
+            hidden.add(name);
+    }
+    return hidden;
+}
+const EDITOR_OPERATIONS = ["create", "update", "delete"];
+/**
+ * Derives truthful per-operation availability. Precedence, most authoritative
+ * first: capability profile verdict → coarse `applyEdits` capability → host
+ * override → structural preconditions. Every layer can only deny.
+ */
+export function resolveEditorOperations(input) {
+    const gate = capabilityGate(input);
+    return EDITOR_OPERATIONS.map((operation) => {
+        if (gate)
+            return { operation, available: false, ...gate };
+        const override = normalizeOverride(input.overrides?.[operation]);
+        if (override && !override.available) {
+            return {
+                operation,
+                available: false,
+                code: "host-denied",
+                reason: override.reason ?? `The host disabled ${operation} for this source.`,
+            };
+        }
+        if (operation !== "create" && !input.hasFeatureIdentity) {
+            return {
+                operation,
+                available: false,
+                code: "no-feature-identity",
+                reason: `Select a feature with an identity to ${operation} it.`,
+            };
+        }
+        if (operation !== "delete" && input.fields && input.fields.length > 0 && !hasEditableField(input.fields)) {
+            return {
+                operation,
+                available: false,
+                code: "no-editable-fields",
+                reason: "Every field in this source is read-only.",
+            };
+        }
+        return { operation, available: true };
+    });
+}
+function capabilityGate(input) {
+    const decision = input.decisions?.find((entry) => entry.id === "applyEdits");
+    if (decision && decision.effective !== "supported") {
+        const code = UNAVAILABLE_BY_EFFECTIVE[decision.effective] ?? "capability-unknown";
+        const detail = decision.reasons && decision.reasons.length > 0 ? ` (${decision.reasons.join(", ")})` : "";
+        return { code, reason: `${EFFECTIVE_MESSAGE[code]}${detail}` };
+    }
+    if (input.capabilities.applyEdits !== "supported") {
+        return { code: "capability-unsupported", reason: EFFECTIVE_MESSAGE["capability-unsupported"] };
+    }
+    return undefined;
+}
+const UNAVAILABLE_BY_EFFECTIVE = {
+    unsupported: "capability-unsupported",
+    unknown: "capability-unknown",
+    "policy-disabled": "policy-disabled",
+    "peer-unavailable": "peer-unavailable",
+    "authorization-required": "authorization-required",
+    "authorization-denied": "authorization-denied",
+};
+const EFFECTIVE_MESSAGE = {
+    "capability-unsupported": "This source does not support editing.",
+    "capability-unknown": "Editing support for this source could not be established.",
+    "authorization-required": "Sign in with edit permission to edit this source.",
+    "authorization-denied": "Your account is not permitted to edit this source.",
+    "policy-disabled": "Editing is disabled for this source by policy.",
+    "peer-unavailable": "The service that applies edits is unavailable.",
+    "host-denied": "The host disabled this operation.",
+    "no-feature-identity": "Select a feature with an identity first.",
+    "no-editable-fields": "Every field in this source is read-only.",
+};
+function normalizeOverride(override) {
+    if (override === undefined)
+        return undefined;
+    if (typeof override === "boolean")
+        return { available: override };
+    return { available: override.available, ...(override.reason ? { reason: override.reason } : {}) };
+}
+function hasEditableField(fields) {
+    return fields.some((field) => field.editable !== false);
+}
+/** Looks one operation's availability up out of a resolved list. */
+export function editorOperationAvailability(availability, operation) {
+    return (availability.find((entry) => entry.operation === operation) ?? {
+        operation,
+        available: false,
+        code: "capability-unknown",
+        reason: EFFECTIVE_MESSAGE["capability-unknown"],
+    });
+}
+/**
+ * Builds the renderable form from resolved field metadata plus the contract's
+ * own validation result — no service field names, no protocol branching
+ * (REQ-001).
+ */
+export function buildEditorFormModel(input) {
+    const hidden = hiddenEditorFieldNames(input.subtypes, input.values);
+    const errorsByField = new Map();
+    const formErrors = [];
+    for (const error of input.validation.errors) {
+        if (error.fieldName === undefined) {
+            formErrors.push(error.message);
+            continue;
+        }
+        const bucket = errorsByField.get(error.fieldName) ?? [];
+        bucket.push(error.message);
+        errorsByField.set(error.fieldName, bucket);
+    }
+    const controls = input.fields
+        .filter((field) => !hidden.has(field.name))
+        .map((field) => buildControl(field, input, errorsByField.get(field.name) ?? [], field.name === input.subtypes?.field));
+    // Field-scoped errors for hidden fields would otherwise be invisible.
+    for (const [name, messages] of errorsByField) {
+        if (hidden.has(name))
+            formErrors.push(...messages);
+    }
+    const active = resolveActiveEditorSubtype(input.subtypes, input.values);
+    return {
+        operation: input.operation,
+        controls,
+        valid: input.validation.valid,
+        formErrors,
+        errors: input.validation.errors,
+        ...(input.subtypes
+            ? {
+                subtype: {
+                    field: input.subtypes.field,
+                    code: active?.code ?? subtypeCodeOf(input.values[input.subtypes.field]),
+                    ...(active?.name ? { name: active.name } : {}),
+                    choices: input.subtypes.subtypes.map((subtype) => ({
+                        value: String(subtype.code),
+                        label: subtype.name,
+                    })),
+                },
+            }
+            : {}),
+    };
+}
+function buildControl(field, input, errors, subtypeField) {
+    const kind = editorControlKind(field);
+    const raw = input.values[field.name];
+    const value = raw === undefined ? field.defaultValue : raw;
+    // A server-assigned field is read-only in the form, but on a create draft
+    // the contract deliberately does not *require* it — mirror that here so the
+    // form never demands a value the service supplies.
+    const serverAssignedOnCreate = input.operation === "create" && field.editable === false;
+    const range = field.domain?.type === "range" ? field.domain.range : undefined;
+    return {
+        name: field.name,
+        label: field.alias ?? field.name,
+        kind,
+        value: value ?? null,
+        required: (field.required === true || field.nullable === false) && !serverAssignedOnCreate,
+        readOnly: field.editable === false || input.operation === "delete",
+        nullable: field.nullable !== false,
+        ...(typeof field.length === "number" && kind !== "number" ? { maxLength: field.length } : {}),
+        ...(range ? { min: range[0], max: range[1] } : {}),
+        ...(kind === "select" ? { choices: editorChoices(field) } : {}),
+        subtypeField,
+        errors,
+    };
+}
+/** Control kind for a field: coded-value domains select, otherwise by type. */
+export function editorControlKind(field) {
+    if (field.domain?.type === "coded-value" && (field.domain.codedValues?.length ?? 0) > 0)
+        return "select";
+    const type = (field.type ?? "").toLowerCase();
+    if (type.includes("bool"))
+        return "checkbox";
+    if (type.includes("datetime") || type.includes("timestamp"))
+        return "datetime";
+    if (type.includes("date"))
+        return "date";
+    if (type.includes("int") ||
+        type.includes("double") ||
+        type.includes("single") ||
+        type.includes("float") ||
+        type.includes("decimal") ||
+        type.includes("number") ||
+        field.domain?.type === "range") {
+        return "number";
+    }
+    if (typeof field.length === "number" && field.length > 255)
+        return "textarea";
+    return "text";
+}
+function editorChoices(field) {
+    return (field.domain?.codedValues ?? []).map((coded) => ({
+        value: String(coded.code),
+        label: coded.name || String(coded.code),
+    }));
+}
+// ── raw control input → typed attribute value ────────────────────────────
+/**
+ * Coerces raw control input (always a string from a DOM `value`, or a boolean
+ * from a checkbox) to the typed attribute value the source expects.
+ *
+ * Coded-value fields resolve back to the domain code's own type, so a numeric
+ * subtype or status code round-trips as a number rather than the `"3"` an
+ * `<option value>` carries — otherwise every coded-value edit would fail the
+ * contract's own domain check.
+ */
+export function coerceEditorFieldValue(field, raw) {
+    if (typeof raw === "boolean")
+        return raw;
+    if (raw === null)
+        return null;
+    const kind = editorControlKind(field);
+    if (kind === "select") {
+        const coded = (field.domain?.codedValues ?? []).find((entry) => String(entry.code) === raw);
+        if (coded)
+            return coded.code;
+        return raw === "" ? emptyValueFor(field) : raw;
+    }
+    if (raw === "")
+        return emptyValueFor(field);
+    if (kind === "checkbox")
+        return raw === "true" || raw === "on";
+    if (kind === "number") {
+        const parsed = Number(raw);
+        return Number.isFinite(parsed) ? parsed : raw;
+    }
+    return raw;
+}
+function emptyValueFor(field) {
+    return field.nullable === false ? "" : null;
+}
+/** Renders a typed attribute value as the string a DOM control carries. */
+export function editorFieldInputValue(field, value) {
+    if (value === undefined || value === null)
+        return "";
+    if (typeof value === "boolean")
+        return String(value);
+    if (value instanceof Date)
+        return isoForControl(editorControlKind(field), value);
+    if (typeof value === "number" && (editorControlKind(field) === "date" || editorControlKind(field) === "datetime")) {
+        return isoForControl(editorControlKind(field), new Date(value));
+    }
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return String(value);
+}
+function isoForControl(kind, date) {
+    if (Number.isNaN(date.getTime()))
+        return "";
+    const iso = date.toISOString();
+    return kind === "datetime" ? iso.slice(0, 16) : iso.slice(0, 10);
+}
+/**
+ * Redacts a staged attachment mutation down to safe descriptive metadata.
+ * String payloads (potentially credential-bearing URLs) never survive: only a
+ * `name`, which falls back to a neutral placeholder rather than the payload.
+ */
+export function redactEditorAttachment(mutation, index, status = "staged", error) {
+    const payload = mutation.attachment;
+    const blobLike = payload;
+    const name = mutation.name ??
+        (typeof blobLike?.name === "string" ? blobLike.name : undefined) ??
+        (mutation.operation === "delete" ? `${mutation.attachmentIds?.length ?? 0} attachment(s)` : "attachment");
+    return {
+        index,
+        operation: mutation.operation,
+        name,
+        ...((mutation.contentType ?? (typeof blobLike?.type === "string" && blobLike.type))
+            ? { contentType: mutation.contentType ?? blobLike?.type }
+            : {}),
+        ...(typeof blobLike?.size === "number" ? { size: blobLike.size } : {}),
+        status,
+        ...(error ? { error } : {}),
+    };
+}
+// ── helpers ──────────────────────────────────────────────────────────────
+function sameCode(left, right) {
+    if (left === right)
+        return true;
+    return String(left) === String(right);
+}
+function subtypeCodeOf(value) {
+    if (typeof value === "number" || typeof value === "string")
+        return value;
+    return undefined;
+}

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

@@ -0,0 +1,125 @@
+/**
+ * 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 type { EditSketchTool, EditSketchToolCapability } from "../contract/edit-sketch.js";
+import { type SnapIndex, type SnappingConfig } from "../contract/edit-snapping.js";
+import { type BindTerraDrawSketchOptions, type CreateTerraDrawSnappingOptions, type TerraDrawSketchInstance } from "../runtime/terra-draw-sketch.js";
+import type { HonuaFeatureEditorWorkflow } from "./feature-editor-workflow.js";
+/**
+ * The geometry seam `<honua-feature-editor>` composes with. Every method is a
+ * no-op-with-a-reason while no draft is open, so a host never has to branch on
+ * the editor's lifecycle.
+ */
+export interface HonuaEditorSketchAdapter {
+    /** Arms a drawing tool in both the sketch backend and the workflow. */
+    setTool(tool: EditSketchTool): EditSketchToolCapability;
+    /** Switches the backend to reshape/select mode for updating existing geometry. */
+    select(): void;
+    /** Leaves any drawing or select mode. */
+    cancel(): void;
+    /** Undo through the workflow, then re-sync the backend. */
+    undo(): boolean;
+    /** Redo through the workflow, then re-sync the backend. */
+    redo(): boolean;
+    /** Pushes the workflow's current geometry back into the backend. */
+    syncFromModel(): boolean;
+    /**
+     * Resolves once the adapter has finished (re)binding to the workflow's
+     * current draft. Deterministic hook for hosts and tests after `begin()`.
+     */
+    ready(): Promise<void>;
+    /** Detaches from the workflow and the sketch backend. */
+    remove(): void;
+}
+/** Options shared by both adapter factories. */
+export interface HonuaEditorSketchOptions<T = Record<string, unknown>> extends Pick<BindTerraDrawSketchOptions<T>, "transformGeometry" | "restoreGeometry" | "featureFilter" | "toolForMode" | "onFinish" | "onDelete"> {
+    /** Editor workflow whose drafts drive (and are driven by) the sketch backend. */
+    readonly workflow: HonuaFeatureEditorWorkflow<T>;
+    /**
+     * terra-draw modes actually registered on the instance. Defaults to every
+     * canonical drawing mode; used to report truthful tool support.
+     */
+    readonly modes?: readonly string[];
+}
+/**
+ * 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 declare function bindEditorSketch<T = Record<string, unknown>>(draw: TerraDrawSketchInstance, options: HonuaEditorSketchOptions<T>): HonuaEditorSketchAdapter;
+/** SDK snapping inputs for a terra-draw-backed editor. */
+export interface HonuaEditorSnappingOptions {
+    /** Snap index over the loaded snap-source features. */
+    readonly index: SnapIndex;
+    /** Fallback configuration used while no draft is open. */
+    readonly config?: Partial<SnappingConfig>;
+}
+/** Options for the one-call terra-draw default. */
+export interface CreateTerraDrawEditorSketchOptions<T = Record<string, unknown>> extends HonuaEditorSketchOptions<T> {
+    /**
+     * Wire SDK snapping into the terra-draw modes that expose a custom snapping
+     * hook (linestring / polygon). terra-draw resolves its snapping options once,
+     * when the instance is constructed, so these are routed through
+     * {@link editorSnappingOptions} to stay live across draft re-binds.
+     */
+    readonly snapping?: HonuaEditorSnappingOptions;
+}
+/**
+ * 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 declare function editorSnappingOptions<T = Record<string, unknown>>(workflow: HonuaFeatureEditorWorkflow<T>, snapping: HonuaEditorSnappingOptions): CreateTerraDrawSnappingOptions<T>;
+/**
+ * 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 declare function createTerraDrawEditorSketch<T = Record<string, unknown>>(map: unknown, options: CreateTerraDrawEditorSketchOptions<T>): Promise<HonuaEditorSketchAdapter & {
+    stop(): void;
+}>;
+//# sourceMappingURL=feature-editor-sketch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature-editor-sketch.d.ts","sourceRoot":"","sources":["../../../src/web-components/feature-editor-sketch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,wBAAwB,EAA2B,MAAM,4BAA4B,CAAC;AACpH,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,cAAc,EAAyB,MAAM,8BAA8B,CAAC;AAC1G,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,8BAA8B,EAEnC,KAAK,uBAAuB,EAI7B,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAE/E;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACvC,uEAAuE;IACvE,OAAO,CAAC,IAAI,EAAE,cAAc,GAAG,wBAAwB,CAAC;IACxD,kFAAkF;IAClF,MAAM,IAAI,IAAI,CAAC;IACf,yCAAyC;IACzC,MAAM,IAAI,IAAI,CAAC;IACf,2DAA2D;IAC3D,IAAI,IAAI,OAAO,CAAC;IAChB,2DAA2D;IAC3D,IAAI,IAAI,OAAO,CAAC;IAChB,oEAAoE;IACpE,aAAa,IAAI,OAAO,CAAC;IACzB;;;OAGG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,yDAAyD;IACzD,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,gDAAgD;AAChD,MAAM,WAAW,wBAAwB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACnE,SAAQ,IAAI,CACV,0BAA0B,CAAC,CAAC,CAAC,EAC7B,mBAAmB,GAAG,iBAAiB,GAAG,eAAe,GAAG,aAAa,GAAG,UAAU,GAAG,UAAU,CACpG;IACD,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,0BAA0B,CAAC,CAAC,CAAC,CAAC;IACjD;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1D,IAAI,EAAE,uBAAuB,EAC7B,OAAO,EAAE,wBAAwB,CAAC,CAAC,CAAC,GACnC,wBAAwB,CAE1B;AAED,0DAA0D;AAC1D,MAAM,WAAW,0BAA0B;IACzC,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;CAC3C;AAED,mDAAmD;AACnD,MAAM,WAAW,kCAAkC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAE,SAAQ,wBAAwB,CAAC,CAAC,CAAC;IAClH;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,0BAA0B,CAAC;CAChD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/D,QAAQ,EAAE,0BAA0B,CAAC,CAAC,CAAC,EACvC,QAAQ,EAAE,0BAA0B,GACnC,8BAA8B,CAAC,CAAC,CAAC,CAQnC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,2BAA2B,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3E,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE,kCAAkC,CAAC,CAAC,CAAC,GAC7C,OAAO,CAAC,wBAAwB,GAAG;IAAE,IAAI,IAAI,IAAI,CAAA;CAAE,CAAC,CA6BtD"}