@syntrologie/adapt-nav 2.8.0-canary.26 → 2.8.0-canary.260

package/dist/NavWidgetLit.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Adaptive Nav - NavWidgetLit Web Component
+ *
+ * Lit web component equivalent of NavWidget.tsx. Renders a collapsible
+ * navigation tips accordion with per-item conditional visibility, framework-aware
+ * navigation, and CSS variable theming.
+ *
+ * Decorator-free: uses `static override properties` (tsconfig has no
+ * experimentalDecorators).
+ *
+ * Uses light DOM (createRenderRoot returns this) so host-page CSS variables
+ * (--sc-*) are inherited without crossing a shadow boundary.
+ */
+import { LitElement } from 'lit';
+import type { NavConfig, NavWidgetRuntime } from './types';
+export declare class NavWidgetLit extends LitElement {
+    #private;
+    createRenderRoot(): this;
+    static properties: {
+        config: {
+            attribute: boolean;
+        };
+        runtime: {
+            attribute: boolean;
+        };
+        instanceId: {
+            type: StringConstructor;
+        };
+        _expandedIds: {
+            state: boolean;
+        };
+        _renderTick: {
+            state: boolean;
+        };
+        _hoveredId: {
+            state: boolean;
+        };
+    };
+    config: NavConfig;
+    runtime: NavWidgetRuntime | undefined;
+    instanceId: string;
+    /** @internal */ _expandedIds: Set<string>;
+    /** @internal */ _renderTick: number;
+    /** @internal */ _hoveredId: string | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changed: Map<string, unknown>): void;
+    render(): import("lit-html").TemplateResult<1>;
+}
+export declare function registerNavWidgetLit(): void;
+declare global {
+    interface HTMLElementTagNameMap {
+        'syntro-nav-tips': NavWidgetLit;
+    }
+}
+//# sourceMappingURL=NavWidgetLit.d.ts.map

package/dist/NavWidgetLit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavWidgetLit.d.ts","sourceRoot":"","sources":["../src/NavWidgetLit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAQ,UAAU,EAAW,MAAM,KAAK,CAAC;AAMhD,OAAO,KAAK,EAAE,SAAS,EAAgB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AA0FzE,qBAAa,YAAa,SAAQ,UAAU;;IAGjC,gBAAgB;IAMzB,OAAgB,UAAU;;;;;;;;;;;;;;;;;;;MAUxB;IAIF,MAAM,EAAE,SAAS,CAA4D;IAC7E,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAAa;IAClD,UAAU,EAAE,MAAM,CAAgB;IAIlC,gBAAgB,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;IACvD,gBAAgB,CAAC,WAAW,SAAK;IACjC,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAQ;IASzC,iBAAiB,IAAI,IAAI;IAOzB,oBAAoB,IAAI,IAAI;IAO5B,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IA0U5C,MAAM;CAuFhB;AAQD,wBAAgB,oBAAoB,IAAI,IAAI,CAK3C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,iBAAiB,EAAE,YAAY,CAAC;KACjC;CACF"}

package/dist/NavWidgetLit.editable.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Adaptive Nav - NavWidgetLit.editable
+ *
+ * Editable variant of the Nav tips accordion for the canvas editor surface.
+ * Renders the same tip rows as <syntro-nav-tips> but adds:
+ *   - Pencil button per row (shows on hover, calls controller.editItem on click)
+ *   - Pencil click calls controller.editItem to open the modal editor
+ *   - Read-only fallback when controller is null
+ *   - Normal clicks pass through — only pencil and drag handle trigger edit actions
+ *
+ * Tag name: <syntro-nav-tips-editable>
+ *
+ * Decorator-free: uses `static override properties` (matches codebase pattern).
+ * Light DOM: inherits host-page CSS variables (same as <syntro-nav-tips>).
+ *
+ * Cross-package import safety:
+ *   The controller is typed as a structural `ControllerLike` interface defined
+ *   locally — NOT imported from @syntrologie/editor-sdk. This prevents a
+ *   dependency cycle. The real EditModeController satisfies ControllerLike
+ *   structurally.
+ *
+ *   Similarly, `makeSortable` is passed in as a `SortableFn` option rather than
+ *   imported directly — matching the FAQ editable widget pattern (Alternative C
+ *   from the architecture decision log). The sortable is wired via _attachSortable()
+ *   in the updated() lifecycle hook, exactly mirroring FAQAccordionEditableElement.
+ *
+ * Click strategy:
+ *   Row clicks pass through normally — the editable variant does NOT intercept
+ *   them. Only the pencil button (opens modal editor) and drag handle (reorder)
+ *   trigger edit-mode actions. This lets the underlying widget behavior (e.g.
+ *   navigation, scrolling) work as expected in the editor preview.
+ */
+import { LitElement } from 'lit';
+import type { NavConfig } from './types';
+/**
+ * Structural interface — describes only the methods the editable widget needs.
+ * The real EditModeController satisfies this by structural subtyping.
+ *
+ * `tileId` (the host tile's id, threaded in via `instanceId` at mount) scopes
+ * controller calls to the active tile when a canvas has multiple Nav tiles.
+ * It is optional so single-tile and v2 actions-shape canvases continue to work.
+ */
+export interface ControllerLike {
+    editItem(adaptive: string, itemId: string, tileId?: string): void;
+    editContainer(adaptive: string, tileId?: string): void;
+    isModalOpen(): boolean;
+    reorderItems(adaptive: string, newOrder: string[], tileId?: string): void;
+}
+/** Return value from makeSortable. */
+export interface SortableHandle {
+    destroy(): void;
+}
+/** Options subset that NavTipsEditableElement passes into the sortable. */
+export interface SortableOptions {
+    itemSelector: string;
+    handleSelector: string;
+    getItems: () => string[];
+    onReorder: (newOrder: string[]) => void;
+    liveRegion: HTMLElement;
+}
+/**
+ * Structural type matching `makeSortable` from editor-sdk's sortable.ts.
+ * Injected at mount time by NavWidgetLitEditableMountable.
+ * Phase 3.3 will actually wire this; it is accepted here for forward compat.
+ */
+export type SortableFn = (host: HTMLElement, opts: SortableOptions) => SortableHandle;
+/**
+ * <syntro-nav-tips-editable> — light-DOM Lit element.
+ *
+ * Set properties imperatively (no attribute serialisation for objects):
+ *   el.navConfig = { ... };
+ *   el.controller = editModeControllerInstance;  // null → read-only
+ */
+export declare class NavTipsEditableElement extends LitElement {
+    static properties: {
+        navConfig: {
+            attribute: boolean;
+        };
+        controller: {
+            attribute: boolean;
+        };
+        tileId: {
+            attribute: boolean;
+        };
+        _hoveredId: {
+            state: boolean;
+        };
+        _containerHovered: {
+            state: boolean;
+        };
+    };
+    navConfig: NavConfig;
+    /** Null when loaded without an editor context — renders read-only list. */
+    controller: ControllerLike | null;
+    /**
+     * Host tile id, threaded in via the mountable's `instanceId`. Scopes every
+     * controller call so the right tile is targeted when the canvas has more
+     * than one Nav tile (per-route navs). Empty string when unknown.
+     */
+    tileId: string;
+    /**
+     * The `makeSortable` factory to use. Injected by NavWidgetLitEditableMountable
+     * from the editor-sdk bootstrap so there is no direct import from editor-sdk
+     * into this package (which would create a circular dependency).
+     *
+     * Null when running without the editor context (read-only mode).
+     */
+    sortable: SortableFn | null;
+    /**
+     * Shared aria-live region from the modal host, threaded in via mount config.
+     * Falls back to a detached element when running outside the editor context.
+     */
+    liveRegion: HTMLElement | null;
+    _hoveredId: string | null;
+    _containerHovered: boolean;
+    private _sortableHandle;
+    createRenderRoot(): this;
+    connectedCallback(): void;
+    /**
+     * Wire (or re-wire) the sortable whenever the properties it depends on change.
+     * `updated()` fires after every render, including the first, so we don't need
+     * a separate `firstUpdated()` call — using `updated()` alone avoids a double
+     * attach on mount (firstUpdated + updated both fire on first render).
+     */
+    protected updated(changed: Map<string, unknown>): void;
+    disconnectedCallback(): void;
+    private _attachSortable;
+    private _handleEdit;
+    private _handlePencilClick;
+    private _handleContainerEdit;
+    private _renderRow;
+    render(): import("lit-html").TemplateResult<1>;
+}
+/**
+ * Mountable for <syntro-nav-tips-editable>.
+ *
+ * Follows the same mount pattern as NavWidgetLitMountable in runtime.ts.
+ * Accepts a `controller` in addition to `navConfig` so the editor can
+ * wire up the EditModeController at mount time.
+ */
+export declare const NavWidgetLitEditableMountable: {
+    mount(container: HTMLElement, config?: NavConfig & {
+        instanceId?: string;
+        controller?: ControllerLike | null;
+        /** makeSortable factory injected by editor-sdk bootstrap. Phase 3.3 wires this. */
+        sortable?: SortableFn | null;
+        /** Shared aria-live region from the modal host for sortable announcements. */
+        liveRegion?: HTMLElement | null;
+    }): () => void;
+};
+//# sourceMappingURL=NavWidgetLit.editable.d.ts.map

package/dist/NavWidgetLit.editable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavWidgetLit.editable.d.ts","sourceRoot":"","sources":["../src/NavWidgetLit.editable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAQ,UAAU,EAAW,MAAM,KAAK,CAAC;AAEhD,OAAO,KAAK,EAAE,SAAS,EAAgB,MAAM,SAAS,CAAC;AAMvD;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClE,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvD,WAAW,IAAI,OAAO,CAAC;IACvB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3E;AAMD,sCAAsC;AACtC,MAAM,WAAW,cAAc;IAC7B,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,2EAA2E;AAC3E,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,MAAM,EAAE,CAAC;IACzB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IACxC,UAAU,EAAE,WAAW,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,eAAe,KAAK,cAAc,CAAC;AA6JtF;;;;;;GAMG;AACH,qBAAa,sBAAuB,SAAQ,UAAU;IAKpD,OAAgB,UAAU;;;;;;;;;;;;;;;;MAQxB;IAMF,SAAS,EAAE,SAAS,CAIlB;IAEF,2EAA2E;IAC3E,UAAU,EAAE,cAAc,GAAG,IAAI,CAAQ;IAEzC;;;;OAIG;IACH,MAAM,SAAM;IAEZ;;;;;;OAMG;IACH,QAAQ,EAAE,UAAU,GAAG,IAAI,CAAQ;IAEnC;;;OAGG;IACH,UAAU,EAAE,WAAW,GAAG,IAAI,CAAQ;IAEtC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAQ;IACjC,iBAAiB,UAAS;IAM1B,OAAO,CAAC,eAAe,CAA+B;IAM7C,gBAAgB;IAIhB,iBAAiB,IAAI,IAAI;IASlC;;;;;OAKG;cACgB,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAQtD,oBAAoB,IAAI,IAAI;IAMrC,OAAO,CAAC,eAAe;IAsBvB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,oBAAoB;IAU5B,OAAO,CAAC,UAAU;IAqDT,MAAM;CA8EhB;AAcD;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B;qBAE3B,WAAW,WACb,SAAS,GAAG;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;QACnC,mFAAmF;QACnF,QAAQ,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;QAC7B,8EAA8E;QAC9E,UAAU,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;KACjC;CAiCJ,CAAC"}

package/dist/NavWidgetLit.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * NavWidgetLit — Vitest + @open-wc/testing-helpers unit tests
+ *
+ * Tests cover: rendering, expand/collapse, nav-tip-clicked event, XSS rejection,
+ * empty state, category grouping, and visibility filtering (triggerWhen).
+ */
+export {};
+//# sourceMappingURL=NavWidgetLit.test.d.ts.map

package/dist/NavWidgetLit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavWidgetLit.test.d.ts","sourceRoot":"","sources":["../src/NavWidgetLit.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/chunk-7DTOSQNC.js

@@ -0,0 +1,43 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+export {
+  __commonJS,
+  __toESM,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod
+};
+//# sourceMappingURL=chunk-7DTOSQNC.js.map

package/dist/chunk-7DTOSQNC.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}