@easemate/web-kit 0.2.0 → 0.3.1

package/build/decorators.js

@@ -0,0 +1,889 @@
+// swc:/home/runner/work/web-kit/web-kit/packages/core/src/decorators/Component.ts
+import { html, render } from "lit-html";
+var styleCache = /* @__PURE__ */ new Map();
+var normalizeTemplate = (template) => {
+  if (typeof template === "function") {
+    return template;
+  }
+  if (template && typeof template === "object" && "_$litTemplate$" in template) {
+    return function() {
+      return template;
+    };
+  }
+  return function() {
+    return null;
+  };
+};
+var fetchStyles = async (urls) => Promise.all(urls.map((url) => {
+  const cached = styleCache.get(url);
+  if (cached) {
+    return cached;
+  }
+  const request = fetch(url).then((response) => response.ok ? response.text() : "").catch(() => "");
+  styleCache.set(url, request);
+  return request;
+}));
+var Component = (options) => (Base, _context) => {
+  const { tag, template, styles = "", styleUrls = [], observedAttributes = [], shadowMode = "open", autoSlot = true } = options;
+  if (!tag) {
+    throw new Error('@Component requires a "tag" option.');
+  }
+  const templateFn = normalizeTemplate(template);
+  class Decorated extends Base {
+    static get observedAttributes() {
+      const parent = "observedAttributes" in Base && Array.isArray(Base.observedAttributes) ? Base.observedAttributes : [];
+      const own = Array.isArray(observedAttributes) ? observedAttributes : [];
+      return Array.from(/* @__PURE__ */ new Set([
+        ...parent,
+        ...own
+      ]));
+    }
+    #shadow;
+    #styles;
+    #styleUrls;
+    #renderScheduled;
+    constructor(...args) {
+      super(...args), this.#styles = styles, this.#styleUrls = [
+        ...styleUrls
+      ], this.#renderScheduled = false;
+      this.#shadow = this.attachShadow({
+        mode: shadowMode
+      });
+      this.renderRoot = this.#shadow;
+    }
+    get shadow() {
+      return this.renderRoot;
+    }
+    connectedCallback() {
+      Base.prototype.connectedCallback?.call(this);
+      void this.#loadStyles().finally(() => {
+        this.requestRender();
+      });
+    }
+    disconnectedCallback() {
+      Base.prototype.disconnectedCallback?.call(this);
+      this.#renderScheduled = false;
+    }
+    attributeChangedCallback(name, oldValue, newValue) {
+      Base.prototype.attributeChangedCallback?.call(this, name, oldValue, newValue);
+      if (oldValue !== newValue) {
+        this.onAttributeChange?.(name, oldValue, newValue);
+      }
+    }
+    requestRender() {
+      if (this.#renderScheduled) {
+        return;
+      }
+      this.#renderScheduled = true;
+      requestAnimationFrame(() => {
+        this.#renderScheduled = false;
+        this.#render();
+      });
+    }
+    async #loadStyles() {
+      if (!this.#styleUrls.length) {
+        return;
+      }
+      const fetched = await fetchStyles(this.#styleUrls);
+      const inlineStyles = this.#styles ? [
+        this.#styles
+      ] : [];
+      this.#styles = [
+        ...inlineStyles,
+        ...fetched.filter(Boolean)
+      ].join("\n");
+    }
+    #render() {
+      const root = this.#shadow;
+      let templateResult;
+      if (typeof this.render === "function") {
+        templateResult = this.render();
+      } else {
+        templateResult = templateFn.call(this, this);
+      }
+      const styleTemplate = this.#styles ? html`<style>${this.#styles}</style>` : null;
+      const slotTemplate = autoSlot ? html`<slot></slot>` : null;
+      const completeTemplate = html`
+          ${styleTemplate}
+          ${templateResult ?? null}
+          ${slotTemplate}
+        `;
+      const commit = () => {
+        render(completeTemplate, root);
+        this.afterRender?.();
+      };
+      if (typeof this.wrapRender === "function") {
+        const fragment = document.createDocumentFragment();
+        const tempDiv = document.createElement("div");
+        render(completeTemplate, tempDiv);
+        fragment.append(...tempDiv.childNodes);
+        this.wrapRender(commit, {
+          fragment,
+          root
+        });
+        return;
+      }
+      commit();
+    }
+  }
+  if (typeof customElements !== "undefined" && !customElements.get(tag)) {
+    customElements.define(tag, Decorated);
+  }
+  return Decorated;
+};
+
+// swc:/home/runner/work/web-kit/web-kit/packages/core/src/decorators/Listen.ts
+var lifecycleHooks = {
+  connectedCallback: /* @__PURE__ */ new WeakMap(),
+  disconnectedCallback: /* @__PURE__ */ new WeakMap()
+};
+var cleanupRegistry = /* @__PURE__ */ new WeakMap();
+var addLifecycleHook = (instance, hookName, handler) => {
+  const store = lifecycleHooks[hookName];
+  let callbacks = store.get(instance);
+  if (!callbacks) {
+    callbacks = /* @__PURE__ */ new Set();
+    store.set(instance, callbacks);
+    const original = instance[hookName];
+    instance[hookName] = function(...args) {
+      callbacks?.forEach((callback) => {
+        callback.apply(this);
+      });
+      if (typeof original === "function") {
+        return original.apply(this, args);
+      }
+      return void 0;
+    };
+  }
+  callbacks.add(handler);
+};
+var registerCleanup = (instance, cleanup) => {
+  let callbacks = cleanupRegistry.get(instance);
+  if (!callbacks) {
+    callbacks = /* @__PURE__ */ new Set();
+    cleanupRegistry.set(instance, callbacks);
+    addLifecycleHook(instance, "disconnectedCallback", function() {
+      const registered = cleanupRegistry.get(this);
+      registered?.forEach((fn) => {
+        try {
+          fn();
+        } catch (error) {
+          console.error("[Listen] cleanup failed", error);
+        }
+      });
+      cleanupRegistry.delete(this);
+    });
+  }
+  callbacks.add(cleanup);
+};
+var resolveTarget = (host, target) => {
+  if (typeof target === "function") {
+    return target(host) ?? null;
+  }
+  if (target instanceof EventTarget) {
+    return target;
+  }
+  switch (target) {
+    case "document":
+      return document;
+    case "window":
+      return window;
+    case "light":
+      return host;
+    default:
+      return host.renderRoot ?? host.shadowRoot ?? host;
+  }
+};
+var normalizeOptions = (selectorOrOptions) => {
+  if (typeof selectorOrOptions === "string") {
+    return {
+      selector: selectorOrOptions
+    };
+  }
+  return selectorOrOptions ?? {};
+};
+var buildOptions = (options) => {
+  return {
+    selector: options.selector ?? null,
+    target: options.target ?? "shadow",
+    prevent: options.prevent ?? false,
+    stop: options.stop ?? false,
+    stopImmediate: options.stopImmediate ?? false,
+    once: options.once ?? false,
+    passive: options.passive,
+    capture: options.capture ?? false,
+    when: options.when ?? null
+  };
+};
+function Listen(eventName, selectorOrOptions) {
+  if (!eventName) {
+    throw new Error("@Listen requires an event name.");
+  }
+  const listenConfig = buildOptions(normalizeOptions(selectorOrOptions));
+  return (originalMethod, context) => {
+    context.addInitializer(function() {
+      let attached = false;
+      const attach = () => {
+        if (attached) {
+          return;
+        }
+        const target = resolveTarget(this, listenConfig.target);
+        if (!target || typeof target.addEventListener !== "function") {
+          console.warn(`@Listen unable to resolve target for ${String(eventName)}`);
+          return;
+        }
+        const eventOptions = {
+          capture: listenConfig.capture,
+          once: listenConfig.once,
+          passive: listenConfig.passive !== void 0 ? listenConfig.passive : !listenConfig.prevent
+        };
+        const handler = (event) => {
+          const typedEvent = event;
+          if (listenConfig.prevent) {
+            typedEvent.preventDefault();
+          }
+          if (listenConfig.stopImmediate) {
+            typedEvent.stopImmediatePropagation();
+          } else if (listenConfig.stop) {
+            typedEvent.stopPropagation();
+          }
+          let matched = null;
+          if (listenConfig.selector) {
+            const path = typedEvent.composedPath();
+            matched = path.find((node) => node instanceof Element && node.matches(listenConfig.selector)) ?? null;
+            if (!matched) {
+              return;
+            }
+          }
+          if (listenConfig.when && !listenConfig.when(typedEvent, matched)) {
+            return;
+          }
+          if (listenConfig.selector) {
+            void originalMethod.call(this, typedEvent, matched);
+          } else {
+            const targetNode = typedEvent.target instanceof Element ? typedEvent.target : null;
+            void originalMethod.call(this, typedEvent, targetNode);
+          }
+        };
+        target.addEventListener(eventName, handler, eventOptions);
+        attached = true;
+        registerCleanup(this, () => {
+          target.removeEventListener(eventName, handler, eventOptions);
+          attached = false;
+        });
+      };
+      queueMicrotask(attach);
+      addLifecycleHook(this, "connectedCallback", attach);
+    });
+  };
+}
+
+// swc:/home/runner/work/web-kit/web-kit/packages/core/src/utils/dismiss-controller.ts
+var DismissController = class {
+  #onDismiss;
+  #context;
+  #active;
+  constructor(options) {
+    this.#context = null;
+    this.#active = false;
+    this.#handlePointerDown = (event) => {
+      if (!this.#context) {
+        return;
+      }
+      const { owner, content, triggers } = this.#context;
+      const path = event.composedPath();
+      if (path.some((node) => node instanceof Element && node.hasAttribute("data-select-ignore"))) {
+        return;
+      }
+      if (path.includes(owner)) {
+        return;
+      }
+      if (content && path.includes(content)) {
+        return;
+      }
+      if (triggers.some((trigger) => path.includes(trigger))) {
+        return;
+      }
+      this.#onDismiss(event);
+    };
+    this.#handleKeyDown = (event) => {
+      if (event.key !== "Escape" || !this.#context) {
+        return;
+      }
+      event.preventDefault();
+      const active = document.activeElement;
+      if (!active) {
+        this.#onDismiss(event);
+        return;
+      }
+      const { owner, content, triggers } = this.#context;
+      const path = event.composedPath();
+      if (path.includes(owner) || owner.contains(active)) {
+        this.#onDismiss(event);
+        return;
+      }
+      if (content && (path.includes(content) || content.contains(active))) {
+        this.#onDismiss(event);
+        return;
+      }
+      if (triggers.some((trigger) => path.includes(trigger) || trigger.contains(active))) {
+        this.#onDismiss(event);
+      }
+    };
+    this.#onDismiss = options.onDismiss;
+  }
+  connect(context) {
+    this.#context = {
+      owner: context.owner,
+      content: context.content ?? null,
+      triggers: (context.triggers ?? []).filter((el) => el instanceof HTMLElement)
+    };
+    if (!this.#active) {
+      document.addEventListener("pointerdown", this.#handlePointerDown, true);
+      document.addEventListener("keydown", this.#handleKeyDown, true);
+      this.#active = true;
+    }
+  }
+  disconnect() {
+    if (!this.#active) {
+      return;
+    }
+    document.removeEventListener("pointerdown", this.#handlePointerDown, true);
+    document.removeEventListener("keydown", this.#handleKeyDown, true);
+    this.#active = false;
+    this.#context = null;
+  }
+  #handlePointerDown;
+  #handleKeyDown;
+};
+
+// src/utils/outside-click.ts
+var registry = /* @__PURE__ */ new WeakMap();
+var toDismissContext = (host, options) => {
+  if (options.disabled?.(host)) {
+    return null;
+  }
+  const resolved = options.resolve(host);
+  if (!resolved) {
+    return null;
+  }
+  const owner = resolved.owner ?? host ?? null;
+  if (!(owner instanceof HTMLElement)) {
+    return null;
+  }
+  const content = resolved.content && resolved.content instanceof HTMLElement ? resolved.content : null;
+  const triggers = resolved.triggers?.filter((element) => element instanceof HTMLElement) ?? [];
+  return {
+    owner,
+    content,
+    triggers
+  };
+};
+var createOutsideClickHandle = (host, onDismiss, options) => {
+  const controller = new DismissController({
+    onDismiss(event) {
+      if (options.disabled?.(host)) {
+        return;
+      }
+      onDismiss.call(host, event);
+    }
+  });
+  return {
+    update() {
+      const context = toDismissContext(host, options);
+      if (!context) {
+        controller.disconnect();
+        return;
+      }
+      controller.connect(context);
+    },
+    disconnect() {
+      controller.disconnect();
+    }
+  };
+};
+var registerOutsideClickHandle = (host, handle) => {
+  let handles = registry.get(host);
+  if (!handles) {
+    handles = /* @__PURE__ */ new Set();
+    registry.set(host, handles);
+  }
+  handles.add(handle);
+};
+var updateOutsideClickHandles = (host) => {
+  const handles = registry.get(host);
+  if (!handles) {
+    return;
+  }
+  handles.forEach((handle) => {
+    handle.update();
+  });
+};
+var disconnectOutsideClickHandles = (host) => {
+  const handles = registry.get(host);
+  if (!handles) {
+    return;
+  }
+  handles.forEach((handle) => {
+    handle.disconnect();
+  });
+};
+
+// swc:/home/runner/work/web-kit/web-kit/packages/core/src/decorators/OutsideClick.ts
+var lifecycleApplied = /* @__PURE__ */ new WeakSet();
+var wrapMethod = (host, name, hook, callHookFirst = false) => {
+  const original = host[name];
+  host[name] = function(...args) {
+    if (callHookFirst) {
+      hook.call(this);
+    }
+    let result;
+    if (typeof original === "function") {
+      result = original.apply(this, args);
+    }
+    if (!callHookFirst) {
+      hook.call(this);
+    }
+    return result;
+  };
+};
+var ensureLifecycle = (host) => {
+  if (lifecycleApplied.has(host)) {
+    return;
+  }
+  lifecycleApplied.add(host);
+  wrapMethod(host, "connectedCallback", function() {
+    updateOutsideClickHandles(this);
+  });
+  wrapMethod(host, "afterRender", function() {
+    updateOutsideClickHandles(this);
+  });
+  wrapMethod(host, "disconnectedCallback", function() {
+    disconnectOutsideClickHandles(this);
+  }, true);
+};
+function OutsideClick(options = {}) {
+  return (originalMethod, context) => {
+    context.addInitializer(function() {
+      ensureLifecycle(this);
+      const resolve = options.resolve ?? ((host) => {
+        return {
+          owner: options.owner?.(host),
+          content: options.content?.(host),
+          triggers: options.triggers?.(host)
+        };
+      });
+      const handle = createOutsideClickHandle(this, (event) => {
+        originalMethod.call(this, event);
+      }, {
+        resolve,
+        disabled: options.disabled
+      });
+      registerOutsideClickHandle(this, handle);
+      if (this.isConnected) {
+        updateOutsideClickHandles(this);
+      }
+    });
+  };
+}
+
+// swc:/home/runner/work/web-kit/web-kit/packages/core/src/decorators/Prop.ts
+var renderQueue = /* @__PURE__ */ new WeakMap();
+var cleanupRegistry2 = /* @__PURE__ */ new WeakMap();
+var observerRegistry = /* @__PURE__ */ new WeakMap();
+var internalMutations = /* @__PURE__ */ new WeakMap();
+var scheduleRender = (instance) => {
+  if (typeof instance.requestRender === "function") {
+    instance.requestRender();
+    return;
+  }
+  if (typeof instance.render !== "function") {
+    return;
+  }
+  if (renderQueue.get(instance)) {
+    return;
+  }
+  renderQueue.set(instance, true);
+  requestAnimationFrame(() => {
+    renderQueue.delete(instance);
+    instance.render?.();
+  });
+};
+var toKebabCase = (value) => String(value).replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+var registerCleanup2 = (instance, cleanup) => {
+  let callbacks = cleanupRegistry2.get(instance);
+  if (!callbacks) {
+    callbacks = /* @__PURE__ */ new Set();
+    cleanupRegistry2.set(instance, callbacks);
+    const original = instance.disconnectedCallback;
+    instance.disconnectedCallback = function(...args) {
+      const registered = cleanupRegistry2.get(this);
+      registered?.forEach((callback) => {
+        try {
+          callback();
+        } catch (error) {
+          console.error("[Prop] cleanup failed", error);
+        }
+      });
+      cleanupRegistry2.delete(this);
+      if (typeof original === "function") {
+        return original.apply(this, args);
+      }
+      return void 0;
+    };
+  }
+  callbacks.add(cleanup);
+};
+var markInternalMutation = (host, attribute) => {
+  let attributes = internalMutations.get(host);
+  if (!attributes) {
+    attributes = /* @__PURE__ */ new Set();
+    internalMutations.set(host, attributes);
+  }
+  attributes.add(attribute);
+};
+var isInternalMutation = (host, attribute) => {
+  const attributes = internalMutations.get(host);
+  if (!attributes) {
+    return false;
+  }
+  const hasAttribute = attributes.has(attribute);
+  if (hasAttribute) {
+    attributes.delete(attribute);
+    if (attributes.size === 0) {
+      internalMutations.delete(host);
+    }
+  }
+  return hasAttribute;
+};
+var observeAttribute = (host, attribute, handler) => {
+  let entry = observerRegistry.get(host);
+  if (!entry) {
+    const callbacks = /* @__PURE__ */ new Map();
+    const observer = new MutationObserver((records) => {
+      records.forEach((record) => {
+        const attributeName = record.attributeName;
+        if (!attributeName) {
+          return;
+        }
+        if (isInternalMutation(host, attributeName)) {
+          return;
+        }
+        const listeners2 = callbacks.get(attributeName);
+        if (!listeners2) {
+          return;
+        }
+        const currentValue = record.target.getAttribute(attributeName);
+        for (const listener of listeners2) {
+          listener(currentValue);
+        }
+      });
+    });
+    observer.observe(host, {
+      attributes: true
+    });
+    entry = {
+      observer,
+      callbacks
+    };
+    observerRegistry.set(host, entry);
+    registerCleanup2(host, () => {
+      observer.disconnect();
+      observerRegistry.delete(host);
+    });
+  }
+  let listeners = entry.callbacks.get(attribute);
+  if (!listeners) {
+    listeners = /* @__PURE__ */ new Set();
+    entry.callbacks.set(attribute, listeners);
+  }
+  listeners.add(handler);
+};
+var updateAttribute = (host, attribute, value) => {
+  markInternalMutation(host, attribute);
+  if (value === void 0 || value === null || value === false) {
+    host.removeAttribute(attribute);
+    return;
+  }
+  if (value === true) {
+    host.setAttribute(attribute, "");
+    return;
+  }
+  host.setAttribute(attribute, String(value));
+};
+var resolveType = (type) => {
+  if (!type) {
+    return null;
+  }
+  if (type === Boolean || type === "boolean") {
+    return "boolean";
+  }
+  if (type === Number || type === "number") {
+    return "number";
+  }
+  if (type === Object || type === Array || type === "json") {
+    return "json";
+  }
+  return "string";
+};
+var typeParsers = {
+  boolean(value) {
+    return value !== null;
+  },
+  number(value) {
+    if (value === null || value === "") {
+      return null;
+    }
+    const parsed = Number(value);
+    return Number.isNaN(parsed) ? null : parsed;
+  },
+  json(value) {
+    if (!value) {
+      return null;
+    }
+    try {
+      return JSON.parse(value);
+    } catch (error) {
+      console.warn("[Prop] failed to parse JSON attribute", error);
+      return null;
+    }
+  },
+  string(value) {
+    return value;
+  }
+};
+var typeFormatters = {
+  boolean(value) {
+    return value ? "" : null;
+  },
+  number(value) {
+    if (value === null || value === void 0 || value === "") {
+      return null;
+    }
+    return String(value);
+  },
+  json(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return null;
+    }
+  },
+  string(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    return String(value);
+  }
+};
+var defaultCompare = (previous, next) => previous === next;
+function Prop(options = {}) {
+  const { attribute, reflect = true, type, parse, format, defaultValue, compare = defaultCompare, onChange, onAttributeChange } = options;
+  const resolvedType = resolveType(type);
+  const parseValue = parse ? parse : function(value) {
+    if (!resolvedType) {
+      return value;
+    }
+    return typeParsers[resolvedType].call(this, value);
+  };
+  const formatValue = format ? format : function(value) {
+    if (!resolvedType) {
+      return value ?? null;
+    }
+    return typeFormatters[resolvedType].call(this, value);
+  };
+  return (accessor, context) => {
+    if (context.kind !== "accessor") {
+      throw new Error('@Prop requires the "accessor" keyword on the property.');
+    }
+    const attributeName = attribute ?? toKebabCase(context.name);
+    context.addInitializer(function() {
+      if (!reflect) {
+        return;
+      }
+      observeAttribute(this, attributeName, (rawValue) => {
+        if (isInternalMutation(this, attributeName)) {
+          return;
+        }
+        const parsed = parseValue.call(this, rawValue);
+        const previous = accessor.get.call(this);
+        if (compare(previous, parsed)) {
+          return;
+        }
+        accessor.set.call(this, parsed);
+        onAttributeChange?.call(this, parsed, previous);
+        scheduleRender(this);
+      });
+    });
+    return {
+      get() {
+        return accessor.get.call(this);
+      },
+      set(value) {
+        const previous = accessor.get.call(this);
+        if (compare(previous, value)) {
+          return;
+        }
+        accessor.set.call(this, value);
+        if (reflect) {
+          const formatted = formatValue.call(this, value);
+          updateAttribute(this, attributeName, formatted);
+        }
+        onChange?.call(this, value, previous);
+        scheduleRender(this);
+      },
+      init(initialValue) {
+        let value = initialValue;
+        if (this.hasAttribute(attributeName)) {
+          value = parseValue.call(this, this.getAttribute(attributeName));
+        } else if (value === void 0 && defaultValue !== void 0) {
+          value = typeof defaultValue === "function" ? defaultValue.call(this) : defaultValue;
+        }
+        if (reflect) {
+          const formatted = formatValue.call(this, value);
+          updateAttribute(this, attributeName, formatted);
+        }
+        return value;
+      }
+    };
+  };
+}
+
+// swc:/home/runner/work/web-kit/web-kit/packages/core/src/decorators/Query.ts
+var defaultOptions = {
+  all: false,
+  closest: false,
+  from: "shadow",
+  fallback: null
+};
+var resolveFallback = (fallback, host) => {
+  if (typeof fallback === "function") {
+    return fallback(host);
+  }
+  return fallback;
+};
+var resolveRoot = (host, option) => {
+  switch (option) {
+    case "document":
+      return document;
+    case "light":
+      return host;
+    default:
+      return host.renderRoot ?? host.shadowRoot ?? host;
+  }
+};
+var resolveQuery = (host, selector, options) => {
+  if (options.closest) {
+    const result = host.closest(selector);
+    return result ?? resolveFallback(options.fallback, host) ?? null;
+  }
+  const root = resolveRoot(host, options.from);
+  if (!root) {
+    return options.all ? resolveFallback(options.fallback, host) ?? [] : resolveFallback(options.fallback, host) ?? null;
+  }
+  if (options.all) {
+    const elements = Array.from(root.querySelectorAll(selector));
+    return elements.length > 0 ? elements : resolveFallback(options.fallback, host) ?? [];
+  }
+  const match = root.querySelector(selector);
+  return match ?? resolveFallback(options.fallback, host) ?? null;
+};
+var createQueryDecorator = (selector, options) => {
+  return (_target, context) => {
+    if (context.kind === "accessor") {
+      const descriptor = {
+        get() {
+          return resolveQuery(this, selector, options);
+        },
+        set(_value) {
+        }
+      };
+      return descriptor;
+    }
+    context.addInitializer(function() {
+      Object.defineProperty(this, context.name, {
+        configurable: true,
+        enumerable: true,
+        get: () => resolveQuery(this, selector, options)
+      });
+    });
+    return;
+  };
+};
+function Query(selector, userOptions) {
+  if (!selector) {
+    throw new Error("@Query requires a selector.");
+  }
+  if (userOptions) {
+    const merged2 = {
+      ...defaultOptions,
+      ...userOptions
+    };
+    return createQueryDecorator(selector, merged2);
+  }
+  const merged = defaultOptions;
+  return createQueryDecorator(selector, merged);
+}
+
+// swc:/home/runner/work/web-kit/web-kit/packages/core/src/decorators/Watch.ts
+var renderQueue2 = /* @__PURE__ */ new WeakMap();
+var scheduleRender2 = (instance) => {
+  if (typeof instance.requestRender === "function") {
+    instance.requestRender();
+    return;
+  }
+  if (typeof instance.render !== "function") {
+    return;
+  }
+  if (renderQueue2.get(instance)) {
+    return;
+  }
+  renderQueue2.set(instance, true);
+  requestAnimationFrame(() => {
+    renderQueue2.set(instance, false);
+    instance.render?.();
+  });
+};
+var defaultCompare2 = (previous, next) => previous === next;
+function Watch(options = {}) {
+  const { compare = defaultCompare2, onChange, transform } = options;
+  return (accessor, context) => {
+    if (context.kind !== "accessor") {
+      throw new Error('@Watch requires the "accessor" keyword on the property.');
+    }
+    return {
+      get() {
+        return accessor.get.call(this);
+      },
+      set(value) {
+        const previous = accessor.get.call(this);
+        if (compare(previous, value)) {
+          return;
+        }
+        accessor.set.call(this, value);
+        if (onChange) {
+          onChange.call(this, value, previous);
+        }
+        scheduleRender2(this);
+      },
+      init(initialValue) {
+        if (transform) {
+          return transform.call(this, initialValue);
+        }
+        return initialValue;
+      }
+    };
+  };
+}
+export {
+  Component,
+  Listen,
+  OutsideClick,
+  Prop,
+  Query,
+  Watch
+};
+//# sourceMappingURL=decorators.js.map