@openelement/element 0.41.0-alpha.1

package/src/open-element-render.js

@@ -0,0 +1,91 @@
+/**
+ * Internal rendering helpers for OpenElement.
+ *
+ * Extracted from open-element.ts to keep the base class focused on its
+ * public lifecycle API. These functions are NOT part of the public package
+ * surface and should only be consumed by OpenElement itself.
+ *
+ * @internal
+ * @module @openelement/element/open-element-render
+ */ import { renderToDom } from '@openelement/core';
+import { formatError } from '@openelement/core/errors';
+import { createLogger } from '@openelement/core/logger';
+/**
+ * Dispose all reactive effects and declarative event listeners created by
+ * previous renders or hydration passes.
+ *
+ * Returns a fresh, empty event-cleanup array so callers can replace their
+ * existing bag and avoid retaining stale closures.
+ */ export function disposeRenderBindings(effectDisposers, eventCleanups) {
+  for (const d of effectDisposers)d();
+  effectDisposers.clear();
+  for (const f of eventCleanups)f();
+  return [];
+}
+/**
+ * CSR render path for light-DOM components.
+ *
+ * Clears previous bindings, calls render(), caches the result, and mounts the
+ * produced DOM into the element itself.
+ */ export function renderIntoLightDom(instance, effectDisposers, eventCleanups, cache) {
+  const newEventCleanups = disposeRenderBindings(effectDisposers, eventCleanups);
+  const result = instance.render();
+  cache.set(result);
+  const self = instance;
+  while(self.firstChild){
+    self.removeChild(self.firstChild);
+  }
+  if (result != null) {
+    self.appendChild(renderToDom(result, undefined, effectDisposers, instance.signalRegistry));
+  }
+  return newEventCleanups;
+}
+/**
+ * CSR render path for shadow-DOM components.
+ *
+ * Clears previous bindings, calls render(), caches the result, and mounts the
+ * produced DOM into the shadow root.
+ */ export function renderIntoShadowRoot(instance, effectDisposers, eventCleanups, cache) {
+  const root = instance.shadowRoot;
+  if (!root) return eventCleanups;
+  const newEventCleanups = disposeRenderBindings(effectDisposers, eventCleanups);
+  const result = instance.render();
+  cache.set(result);
+  if (result != null) {
+    while(root.firstChild){
+      root.removeChild(root.firstChild);
+    }
+    root.appendChild(renderToDom(result, undefined, effectDisposers, instance.signalRegistry));
+  }
+  return newEventCleanups;
+}
+/**
+ * Render a fallback VNode when the unified render/hydrate path throws.
+ *
+ * Ensures the render root exists, invokes onRenderError(), disposes any
+ * previous bindings, and mounts the fallback content.
+ */ export function renderErrorFallback(instance, error, effectDisposers, eventCleanups, onRenderError) {
+  const ctor = instance.constructor;
+  const isLightDom = ctor.renderMode === 'light';
+  if (!instance.shadowRoot && !isLightDom) {
+    instance.createRenderRoot();
+  }
+  const target = isLightDom ? instance : instance.shadowRoot;
+  if (!target) return [];
+  let fallback;
+  try {
+    fallback = onRenderError(error);
+  } catch (fallbackError) {
+    createLogger('dsd').error(`<${instance.tagName.toLowerCase()}> onRenderError failed: ${formatError(fallbackError)}`);
+    fallback = null;
+  }
+  const newEventCleanups = disposeRenderBindings(effectDisposers, eventCleanups);
+  if (fallback != null) {
+    while(target.firstChild){
+      target.removeChild(target.firstChild);
+    }
+    target.appendChild(renderToDom(fallback, undefined, effectDisposers, instance.signalRegistry));
+  }
+  return newEventCleanups;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/element/src/open-element-render.ts"],"sourcesContent":["/**\n * Internal rendering helpers for OpenElement.\n *\n * Extracted from open-element.ts to keep the base class focused on its\n * public lifecycle API. These functions are NOT part of the public package\n * surface and should only be consumed by OpenElement itself.\n *\n * @internal\n * @module @openelement/element/open-element-render\n */\n\nimport type { VNode } from '@openelement/protocol/vnode';\nimport { renderToDom } from '@openelement/core';\nimport { formatError } from '@openelement/core/errors';\nimport { createLogger } from '@openelement/core/logger';\nimport type { OpenElement } from './open-element.js';\n\n/**\n * Minimal accessor for the VNode cache stored on an OpenElement instance.\n *\n * The cache lives as true private fields on the class, so helpers interact\n * with it through this small facade instead of trying to access #private\n * state from outside the class body.\n */\nexport interface VNodeCacheAccess {\n  /** Read the current cached VNode and whether it is valid. */\n  get(): { vnode: unknown; valid: boolean };\n  /** Store a VNode and mark the cache valid. */\n  set(vnode: unknown): void;\n}\n\n/**\n * Dispose all reactive effects and declarative event listeners created by\n * previous renders or hydration passes.\n *\n * Returns a fresh, empty event-cleanup array so callers can replace their\n * existing bag and avoid retaining stale closures.\n */\nexport function disposeRenderBindings(\n  effectDisposers: Set<() => void>,\n  eventCleanups: Array<() => void>,\n): Array<() => void> {\n  for (const d of effectDisposers) d();\n  effectDisposers.clear();\n  for (const f of eventCleanups) f();\n  return [];\n}\n\n/**\n * CSR render path for light-DOM components.\n *\n * Clears previous bindings, calls render(), caches the result, and mounts the\n * produced DOM into the element itself.\n */\nexport function renderIntoLightDom(\n  instance: OpenElement,\n  effectDisposers: Set<() => void>,\n  eventCleanups: Array<() => void>,\n  cache: VNodeCacheAccess,\n): Array<() => void> {\n  const newEventCleanups = disposeRenderBindings(effectDisposers, eventCleanups);\n\n  const result = instance.render();\n  cache.set(result);\n\n  const self = instance as HTMLElement;\n  while (self.firstChild) {\n    self.removeChild(self.firstChild);\n  }\n\n  if (result != null) {\n    self.appendChild(renderToDom(result, undefined, effectDisposers, instance.signalRegistry));\n  }\n\n  return newEventCleanups;\n}\n\n/**\n * CSR render path for shadow-DOM components.\n *\n * Clears previous bindings, calls render(), caches the result, and mounts the\n * produced DOM into the shadow root.\n */\nexport function renderIntoShadowRoot(\n  instance: OpenElement,\n  effectDisposers: Set<() => void>,\n  eventCleanups: Array<() => void>,\n  cache: VNodeCacheAccess,\n): Array<() => void> {\n  const root = instance.shadowRoot;\n  if (!root) return eventCleanups;\n\n  const newEventCleanups = disposeRenderBindings(effectDisposers, eventCleanups);\n\n  const result = instance.render();\n  cache.set(result);\n\n  if (result != null) {\n    while (root.firstChild) {\n      root.removeChild(root.firstChild);\n    }\n    root.appendChild(renderToDom(result, undefined, effectDisposers, instance.signalRegistry));\n  }\n\n  return newEventCleanups;\n}\n\n/**\n * Render a fallback VNode when the unified render/hydrate path throws.\n *\n * Ensures the render root exists, invokes onRenderError(), disposes any\n * previous bindings, and mounts the fallback content.\n */\nexport function renderErrorFallback(\n  instance: OpenElement,\n  error: unknown,\n  effectDisposers: Set<() => void>,\n  eventCleanups: Array<() => void>,\n  onRenderError: (error: unknown) => VNode | null,\n): Array<() => void> {\n  const ctor = instance.constructor as typeof OpenElement;\n  const isLightDom = ctor.renderMode === 'light';\n\n  if (!instance.shadowRoot && !isLightDom) {\n    instance.createRenderRoot();\n  }\n\n  const target = isLightDom ? (instance as HTMLElement) : instance.shadowRoot;\n  if (!target) return [];\n\n  let fallback: VNode | null;\n  try {\n    fallback = onRenderError(error);\n  } catch (fallbackError) {\n    createLogger('dsd').error(\n      `<${instance.tagName.toLowerCase()}> onRenderError failed: ${formatError(fallbackError)}`,\n    );\n    fallback = null;\n  }\n\n  const newEventCleanups = disposeRenderBindings(effectDisposers, eventCleanups);\n\n  if (fallback != null) {\n    while (target.firstChild) {\n      target.removeChild(target.firstChild);\n    }\n    target.appendChild(renderToDom(fallback, undefined, effectDisposers, instance.signalRegistry));\n  }\n\n  return newEventCleanups;\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;;CASC,GAGD,SAAS,WAAW,QAAQ,oBAAoB;AAChD,SAAS,WAAW,QAAQ,2BAA2B;AACvD,SAAS,YAAY,QAAQ,2BAA2B;AAiBxD;;;;;;CAMC,GACD,OAAO,SAAS,sBACd,eAAgC,EAChC,aAAgC;EAEhC,KAAK,MAAM,KAAK,gBAAiB;EACjC,gBAAgB,KAAK;EACrB,KAAK,MAAM,KAAK,cAAe;EAC/B,OAAO,EAAE;AACX;AAEA;;;;;CAKC,GACD,OAAO,SAAS,mBACd,QAAqB,EACrB,eAAgC,EAChC,aAAgC,EAChC,KAAuB;EAEvB,MAAM,mBAAmB,sBAAsB,iBAAiB;EAEhE,MAAM,SAAS,SAAS,MAAM;EAC9B,MAAM,GAAG,CAAC;EAEV,MAAM,OAAO;EACb,MAAO,KAAK,UAAU,CAAE;IACtB,KAAK,WAAW,CAAC,KAAK,UAAU;EAClC;EAEA,IAAI,UAAU,MAAM;IAClB,KAAK,WAAW,CAAC,YAAY,QAAQ,WAAW,iBAAiB,SAAS,cAAc;EAC1F;EAEA,OAAO;AACT;AAEA;;;;;CAKC,GACD,OAAO,SAAS,qBACd,QAAqB,EACrB,eAAgC,EAChC,aAAgC,EAChC,KAAuB;EAEvB,MAAM,OAAO,SAAS,UAAU;EAChC,IAAI,CAAC,MAAM,OAAO;EAElB,MAAM,mBAAmB,sBAAsB,iBAAiB;EAEhE,MAAM,SAAS,SAAS,MAAM;EAC9B,MAAM,GAAG,CAAC;EAEV,IAAI,UAAU,MAAM;IAClB,MAAO,KAAK,UAAU,CAAE;MACtB,KAAK,WAAW,CAAC,KAAK,UAAU;IAClC;IACA,KAAK,WAAW,CAAC,YAAY,QAAQ,WAAW,iBAAiB,SAAS,cAAc;EAC1F;EAEA,OAAO;AACT;AAEA;;;;;CAKC,GACD,OAAO,SAAS,oBACd,QAAqB,EACrB,KAAc,EACd,eAAgC,EAChC,aAAgC,EAChC,aAA+C;EAE/C,MAAM,OAAO,SAAS,WAAW;EACjC,MAAM,aAAa,KAAK,UAAU,KAAK;EAEvC,IAAI,CAAC,SAAS,UAAU,IAAI,CAAC,YAAY;IACvC,SAAS,gBAAgB;EAC3B;EAEA,MAAM,SAAS,aAAc,WAA2B,SAAS,UAAU;EAC3E,IAAI,CAAC,QAAQ,OAAO,EAAE;EAEtB,IAAI;EACJ,IAAI;IACF,WAAW,cAAc;EAC3B,EAAE,OAAO,eAAe;IACtB,aAAa,OAAO,KAAK,CACvB,CAAC,CAAC,EAAE,SAAS,OAAO,CAAC,WAAW,GAAG,wBAAwB,EAAE,YAAY,gBAAgB;IAE3F,WAAW;EACb;EAEA,MAAM,mBAAmB,sBAAsB,iBAAiB;EAEhE,IAAI,YAAY,MAAM;IACpB,MAAO,OAAO,UAAU,CAAE;MACxB,OAAO,WAAW,CAAC,OAAO,UAAU;IACtC;IACA,OAAO,WAAW,CAAC,YAAY,UAAU,WAAW,iBAAiB,SAAS,cAAc;EAC9F;EAEA,OAAO;AACT"}

package/src/open-element.d.ts

@@ -0,0 +1,176 @@
+import type { StyleSheetLike } from '@openelement/protocol/style-sheet';
+import type { VNode } from '@openelement/protocol/vnode';
+import type { Signal } from '@openelement/protocol/signal';
+/**
+ * SSR-safe base class for OpenElement.
+ *
+ * In browser: extends HTMLElement directly.
+ * In SSR: assigns a minimal stub to globalThis.HTMLElement so the entire
+ * dependency graph shares the same base class.
+ */ declare const _Base: any;
+/**
+ * Zero-dependency Custom Element base class for DSD rendering.
+ *
+ * Provides DSD detection, CSR fallback, event hydration, and style management
+ * without any framework dependency (no Lit, no reactive-element).
+ *
+ * Subclasses MUST override `render(): VNode | null`.
+ */ export declare class OpenElement extends _Base {
+  /** Component stylesheets (SSR-safe - StyleSheet delegates to native CSSStyleSheet in browser). */ static styles?: StyleSheetLike | StyleSheetLike[];
+  /** Rendering mode. Defaults to shadow/DSD; light DOM is explicit opt-in. */ static renderMode?: 'shadow' | 'light';
+  /** v0.25.0: Page head metadata. SSG reads this to inject <title> and <meta> tags. */ static head?: {
+    title?: string;
+    description?: string;
+    ogImage?: string;
+  };
+  /** @internal — use openPipeline({ island: { upgradeStrategy } }) instead */ static client?: {
+    strategy?: 'load' | 'idle' | 'visible' | 'only';
+  };
+  /**
+   * Attributes that trigger attributeChangedCallback.
+   * Subclasses override this to declare reactive attributes.
+   */ static observedAttributes?: string[];
+  /**
+   * Whether to delegate focus within the shadow root.
+   * When true, attachShadow is called with `delegatesFocus: true`.
+   */ static delegatesFocus?: boolean;
+  /**
+   * Whether this element participates in form submission.
+   * When true, ElementInternals are attached in connectedCallback.
+   */ static formAssociated?: boolean;
+  /**
+   * Signal registry for attribute-based hydration (ADR-0065).
+   * Maps signal names → signal objects. Built by registerSignal()
+   * in component constructors, consumed during hydration.
+   *
+   * Exposed internally for render helper modules.
+   */ signalRegistry: Map<string, Signal<unknown>>;
+  /**
+   * Register a signal for hydration by name.
+   * Call in constructor: this.registerSignal('count', this.#count);
+   */ protected registerSignal(name: string, sig: Signal<unknown>): void;
+  /** Reactive route parameters. Updates automatically on SPA navigation. */ get params(): Record<string, string>;
+  set params(value: Record<string, string>);
+  /** ElementInternals for form-associated custom elements */ protected _internals?: ElementInternals;
+  /**
+   * Create or reuse the shadow root.
+   *
+   * DSD detection: if `this.shadowRoot` already exists and has nodes,
+   * the browser pre-populated it from a <template shadowrootmode> tag.
+   * In that case we mark `_dsdHydrated = true` and return the existing root.
+   *
+   * CSR fallback: if no shadow root exists, we call `attachShadow()`. If an
+   * empty shadow root already exists, we reuse it and let connectedCallback()
+   * populate it from render().
+   *
+   * @returns The existing or newly created ShadowRoot.
+   */ createRenderRoot(): ShadowRoot | this;
+  private _applyStyles: any;
+  /**
+   * Lifecycle: called when the element is connected to the DOM.
+   *
+   * DSD path (_dsdHydrated = true):
+   *   - Calls _hydrateEvents() to bind declarative events on existing DOM.
+   *
+   * CSR path (_dsdHydrated = false):
+   *   - Calls createRenderRoot() if no shadow root exists.
+   *   - Renders this.render() through the VNode DOM renderer.
+   *
+   * If formAssociated is true, ElementInternals are attached.
+   */ connectedCallback(): void;
+  private _renderOrHydrate: any;
+  private _hydrateSignals: any;
+  private _hydrateExistingDom: any;
+  /**
+   * v0.23.0: Hook called after DSD hydration completes.
+   *
+   * Subclasses override this instead of relying on fragile
+   * `super.connectedCallback()` call order. At this point the
+   * shadow DOM is populated from DSD and declarative events
+   * (@click, @keydown) are bound.
+   *
+   * No-op by default.
+   */ protected onDsdHydrated(): void;
+  /**
+   * v0.23.0: Hook called after CSR first render completes.
+   *
+   * Subclasses override this for post-render initialization
+   * that depends on the shadow DOM being populated. At this
+   * point render() has been called and declarative events
+   * are bound.
+   *
+   * No-op by default.
+   */ protected onCsrRendered(): void;
+  /**
+   * v0.40.0: Client-side activation hook.
+   *
+   * Called once after the element is connected, the shadow root
+   * is ready, and any DSD hydration or CSR rendering has completed.
+   * This is the right place for framework hydration (Preact, React,
+   * Vue, Lit) to take over the shadow DOM.
+   *
+   * Default implementation is a no-op. Subclasses override this to
+   * hydrate or render framework components into the shadow root.
+   */ protected clientActivate(): void;
+  /**
+   * Hook called when the unified client render/hydrate path throws.
+   * Subclasses may return a VNode fallback.
+   */ protected onRenderError(error: unknown): VNode | null;
+  private _renderErrorFallback: any;
+  /**
+   * Lifecycle: called when the element is disconnected from the DOM.
+   * Aborts all hydration event listeners for cleanup.
+   */ disconnectedCallback(): void;
+  /**
+   * Lifecycle: called when an observed attribute changes.
+   *
+   * Base implementation is a no-op. Subclasses override this to react
+   * to attribute changes, typically by calling `this.render()` to update
+   * the shadow DOM.
+   *
+   * @param name - Attribute name (lowercase).
+   * @param oldValue - Previous value, or null if the attribute was not set.
+   * @param newValue - New value, or null if the attribute was removed.
+   */ attributeChangedCallback(_name: string, _oldValue: string | null, _newValue: string | null): void;
+  /**
+   * Re-render the shadow DOM from `render()` and re-bind declarative events.
+   *
+   * OpenElement intentionally does not include a reactive scheduler. Components
+   * with local state can call this method after state changes instead of
+   * duplicating renderToDom() and event hydration.
+   */ update(): void;
+  /**
+   * ReactiveController-compatible update hook.
+   *
+   * Async state controllers call this method when state changes. Keeping this
+   * tiny alias lets OpenElement host controllers without inheriting Lit or a
+   * scheduler.
+   */ requestUpdate(): void;
+  private _renderIntoLightDom: any;
+  private _renderIntoShadowRoot: any;
+  /**
+   * Read locale from JS property (set by SSR injectProps) first,
+   * then HTML attribute, then fallback to provided default.
+   *
+   * SSR injectProps() sets camelCase JS properties (e.g. this.locale = 'en')
+   * but getAttribute() only reads HTML attributes, which remain null.
+   * This method resolves the mismatch by checking JS property first.
+   *
+   * @param fallback - Default value when neither source has a value. Defaults to 'en'.
+   */ protected _getLocale(fallback?: string): string;
+  /**
+   * Return Shadow DOM content as a VNode.
+   *
+   * Subclasses MUST override this method. During SSR, rendered content is
+   * wrapped in a <template shadowrootmode="open"> tag. During CSR, VNode values
+   * are rendered via renderToDom() with event binding and signal tracking.
+   *
+   * @returns VNode for the shadow DOM content, or null for empty content.
+   */ render(): VNode | null;
+}
+/** OpenElement constructor with framework-convention static properties. */ export interface OpenElementComponentConstructor extends CustomElementConstructor {
+  styles?: StyleSheetLike | StyleSheetLike[];
+  tagName?: string;
+  renderMode?: 'shadow' | 'light';
+  observedAttributes?: string[];
+}