@rusticarcade/palette 0.2.0 → 0.3.1

package/dist/test/index.js

@@ -0,0 +1,347 @@
+// @bun
+// src/test-util/global-env.ts
+import { GlobalRegistrator } from "@happy-dom/global-registrator";
+async function prepareGlobalTestDOM() {
+  await cleanupGlobalTestDOM();
+  GlobalRegistrator.register();
+}
+async function cleanupGlobalTestDOM() {
+  if (typeof document !== "undefined") {
+    while (document.firstChild) {
+      document.removeChild(document.firstChild);
+    }
+  }
+  await Bun.sleep(1);
+  if (GlobalRegistrator.isRegistered) {
+    GlobalRegistrator.unregister();
+  }
+}
+// src/errors.ts
+function getDevError(code) {
+  const DEV_ERROR_INFO = {
+    [0 /* INVARIANT */]: `
+INVARIANT
+A condition has occurred which should never happen, such as a code path that
+shouldn't be reachable when using correct types, or a disallowed state.
+`,
+    [1 /* INVALID_ENV */]: `
+INVALID_ENV
+Failed to find a custom elements registry in this environment. Is a window
+global available with a customElements property?
+`,
+    [100 /* DUPE_TAGNAME */]: `
+DUPE_TAGNAME
+Failed to register a custom element with the tagname %s because another
+custom element is already defined with that name.
+`,
+    [101 /* INVALID_TAGNAME */]: `
+INVALID_TAGNAME
+Failed to determine a valid HTML Tag to use when registering a component as a
+custom element. Specify a static readonly tagName property on your component
+class or provide a tagName argument to Component.register.
+
+Alternatively, you can directly register your element as you would any other
+HTML custom element: customElements.define("my-tag", MyComponentClass);
+`,
+    [300 /* MISSING_ELEMENT */]: `
+MISSING_ELEMENT
+An element was expected to exist but was not found when the DOM was queried.
+`,
+    [301 /* MISSING_STATE */]: `
+MISSING_STATE
+A Component's reactive state was accessed, but no initialState is defined for
+the Component's class. Initial state must be defined as an object or function.
+`,
+    [302 /* INVALID_CONTENT */]: `
+INVALID_CONTENT
+Tried to set a value as content in a template, but the value was not a supported
+type. Values must be a string, HTMLElement.
+
+Instead, got %s: %s.
+`,
+    [200 /* TEMPLATE_INVALID */]: `
+TEMPLATE_INVALID
+The value %s cannot be interpolated via the Template html string helper.
+Values may only be HTMLTemplateElements (template content is adopted) or
+strings (shorthand for a ::swap directive on an element)
+`,
+    [201 /* TEMPLATE_INVALID_NOTATION */]: `
+TEMPLATE_INVALID_NOTATION
+A template value notation failed to parse. Notations must begin with one of
+@, $, *, or #, followed by a dot-separated path of accessor names. Optionally,
+notations may have modifiers around them, such as the NOT() modifier.
+
+The notation that failed to parse was "%s"
+`,
+    [202 /* TEMPLATE_INVALID_COMPONENT */]: `
+TEMPLATE_INVALID_COMPONENT
+Failed to interpolate a Component in an html template string due to the
+Component having an invalid tagName property.
+
+Component "%s" has an invalid tagName property "%s"
+    `,
+    [205 /* TEMPLATE_MISSING_LIST_PARENT */]: `
+TEMPLATE_MISSING_LIST_PARENT
+A template failed to prepare an ::each directive because no valid parent node
+was found for the list to render into.
+`,
+    [203 /* TEMPLATE_INVALID_LIST */]: `
+TEMPLATE_INVALID_LIST
+A template failed to render because an ::each directive fetched a value which
+was not an array of actionable data.
+`,
+    [204 /* TEMPLATE_INVALID_NODE_REF */]: `
+TEMPLATE_INVALID_NODE_REF
+A template failed to prepare a node from a compiled source. Typically, this
+means something is broken within the compiled template rather than an error with
+the template content itself.
+`,
+    [206 /* TEMPLATE_MISSING_LIST_KEY */]: `
+TEMPLATE_MISSING_LIST_KEY
+A template failed to compile because an ::each directive was found on an element
+without a corresponding ::key directive. ::each directives must have a ::key
+directive specified on the same element, whose notation evaluates to a unique
+value for each item in the list.
+
+Example: <li ::each="$items" ::key="#id"> ... </li>
+`,
+    [207 /* TEMPLATE_DUPLICATE_LIST_KEY */]: `
+TEMPLATE_DUPLICATE_LIST_KEY
+A list failed to render because item key %s appeared multiple times when
+resolving list item keys. Each ::key directive must reference a notation whose
+value is unique for each list item.
+`,
+    [303 /* INVALID_STATE_KEY */]: `
+INVALID_STATE_KEY
+Tried to access a state property which does not exist
+
+Key path: %s
+`,
+    [304 /* INVALID_STATE_UPDATE */]: `
+INVALID_STATE_UPDATE
+A Component's setState() was called with a value which could not be patched in
+to the existing component state.
+
+setState() takes a partial object describing state keys to update.
+
+Instead, received: %s
+`,
+    [305 /* STATE_LOCKED */]: `
+STATE_LOCKED
+A State received a request to update or lock while already locked.
+States may be locked using the .lock() method and unlocked using the .unlock()
+method. States lock during async mutations done through the .mutateAsync()
+method if "true" is passed as the second parameter.
+
+You can check the lock status of a State instance with .isLocked
+`,
+    [306 /* MAX_SEQUENTIAL_RENDERS */]: `
+MAX_SEQUENTIAL_RENDERS
+A component has errored after re-rendering more than %s times in the same frame.
+
+This typically happens because state or live attributes are being modified
+during a render lifecycle method such as beforeUpdate() or afterUpdate(). If
+state changes unconditionally during a render, the render will infinitely loop.
+Updating render source data during a render cycle is supported, but infinite
+update loops may occur if unchecked.
+`
+  };
+  return DEV_ERROR_INFO[code];
+}
+
+class PaletteError extends Error {
+  name = "PaletteError";
+  code;
+  constructor(code, ...values) {
+    let message = `Code: ${code}`;
+    if (true) {
+      message += getDevError(code);
+      for (const val of values) {
+        message = message.replace(`%s`, String(val));
+      }
+    }
+    super(message);
+    this.code = code;
+  }
+}
+
+// src/util/attributes.ts
+function serializeAttribute(value) {
+  if (typeof value === "string" || typeof value === "number") {
+    return `${value}`;
+  }
+  if (value === true) {
+    return "";
+  }
+  if (value === null || value === false || value === undefined) {
+    return null;
+  }
+  return value.toString();
+}
+function createAttributeMap(source) {
+  const map = new Map;
+  if (source instanceof HTMLElement) {
+    for (const name of source.getAttributeNames()) {
+      map.set(name, serializeAttribute(source.getAttribute(name)));
+    }
+    return map;
+  }
+  if (source instanceof Map) {
+    for (const [key, val] of source) {
+      map.set(key, serializeAttribute(val));
+    }
+    return map;
+  }
+  if (typeof source === "object" && source !== null) {
+    for (const [key, val] of Object.entries(source)) {
+      map.set(key, serializeAttribute(val));
+    }
+    return map;
+  }
+  throw new PaletteError(0 /* INVARIANT */);
+}
+function applyAttributeMap(target, attrs) {
+  const currentNames = new Set(target.getAttributeNames());
+  const incomingNames = new Set(attrs.keys());
+  const attributesToRemove = currentNames.difference(incomingNames);
+  for (const attr of attributesToRemove) {
+    target.removeAttribute(attr);
+  }
+  for (const [name, val] of attrs) {
+    if (val === null) {
+      target.removeAttribute(name);
+    } else {
+      target.setAttribute(name, val);
+    }
+  }
+}
+// src/util/lru-cache.ts
+class LRUCache {
+  _maxSize;
+  _data;
+  _metrics = { hits: 0, misses: 0 };
+  constructor(maxSize = 500) {
+    if (maxSize <= 0) {
+      throw new Error("LRU Cache capacity must be >= 1");
+    }
+    if (true) {
+      this._metrics = { hits: 0, misses: 0 };
+    }
+    this._maxSize = maxSize;
+    this._data = new Map;
+  }
+  _trim = () => {
+    while (this._data.size > this._maxSize) {
+      const firstKey = this._data.keys().next().value;
+      if (firstKey === undefined) {
+        throw new Error("Absurd");
+      }
+      this._data.delete(firstKey);
+    }
+  };
+  get metrics() {
+    if (true) {
+      const { hits = 0, misses = 0 } = this._metrics ?? {};
+      const lookups = hits + misses;
+      const hitRate = lookups === 0 ? 0 : hits / lookups;
+      return {
+        lookups,
+        hits,
+        misses,
+        capacity: this._maxSize,
+        entries: this._data.size,
+        hitRate
+      };
+    }
+    return {
+      lookups: 0,
+      hits: 0,
+      misses: 0,
+      capacity: 0,
+      entries: 0,
+      hitRate: 0
+    };
+  }
+  setCapacity = (maxSize) => {
+    if (maxSize <= 0 && true) {
+      console.warn("[Palette LRU Cache] Cache size is <= 0. Cache is disabled.");
+    }
+    this._maxSize = maxSize;
+    this._trim();
+  };
+  get(key) {
+    const value = this._data.get(key);
+    if (value === undefined) {
+      if (true) {
+        this._metrics.misses += 1;
+      }
+      return;
+    }
+    this._data.delete(key);
+    this._data.set(key, value);
+    if (true) {
+      this._metrics.hits += 1;
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this._data.has(key)) {
+      this._data.delete(key);
+    }
+    this._data.set(key, value);
+    if (this._data.size > this._maxSize) {
+      this._trim();
+    }
+  }
+  clear() {
+    this._data.clear();
+  }
+  get size() {
+    return this._data.size;
+  }
+}
+var lru_cache_default = LRUCache;
+
+// src/util/fragments.ts
+var fragmentCache = new lru_cache_default;
+// src/test-util/tags.ts
+var randomTagName = () => {
+  const id = crypto.randomUUID().replaceAll("-", "").slice(0, 10);
+  return `test-element-${id}`;
+};
+
+// src/test-util/render.ts
+async function renderTestComponent(component, attributes2) {
+  if (typeof window === "undefined" || typeof window.customElements === "undefined") {
+    throw new Error("Failed to render test component: " + "window.customElements is not available in this environment.");
+  }
+  const useTagname = component.tagName === "" ? randomTagName() : component.tagName;
+  component.tagName = useTagname;
+  if (!customElements.get(useTagname)) {
+    customElements.define(useTagname, component);
+  }
+  const $component = document.createElement(component.tagName);
+  const attributeMap = createAttributeMap(attributes2 ?? {});
+  applyAttributeMap($component, attributeMap);
+  document.body.append($component);
+  await Bun.sleep(1);
+  return $component;
+}
+async function rerenderTestComponent(element) {
+  return new Promise((resolve) => {
+    element.requestRender(async () => {
+      await Bun.sleep(1);
+      resolve();
+    });
+  });
+}
+export {
+  rerenderTestComponent,
+  renderTestComponent,
+  randomTagName,
+  prepareGlobalTestDOM,
+  cleanupGlobalTestDOM
+};
+
+//# debugId=925A43921950535764756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/test-util/global-env.ts", "src/errors.ts", "src/util/attributes.ts", "src/util/lru-cache.ts", "src/util/fragments.ts", "src/test-util/tags.ts", "src/test-util/render.ts"],
  "sourcesContent": [
    "/*\n * Copyright © Rustic Arcade, LLC 2026\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\nimport { GlobalRegistrator } from \"@happy-dom/global-registrator\";\n\n/**\n * Initialize the global test DOM environment (using HappyDOM)\n */\nexport async function prepareGlobalTestDOM(): Promise<void> {\n  await cleanupGlobalTestDOM();\n  GlobalRegistrator.register();\n}\n\n/**\n * Cleanup the global test DOM environment (using HappyDOM)\n */\nexport async function cleanupGlobalTestDOM(): Promise<void> {\n  if (typeof document !== \"undefined\") {\n    while (document.firstChild) {\n      document.removeChild(document.firstChild);\n    }\n  }\n\n  await Bun.sleep(1);\n\n  if (GlobalRegistrator.isRegistered) {\n    GlobalRegistrator.unregister();\n  }\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n/**\n * Possible error types for {@link PaletteError}\n *\n * Codes are categorized into groups by the 100's:\n *\n * - 0 - 99: Invariants\n * - 100 - 199: Custom Elements / Environment Errors\n * - 200 - 299: Templating Errors\n * - 300 - 399: Runtime Errors\n */\nexport const enum ErrorCode {\n  // 0 - 99: Invariants\n  INVARIANT = 0,\n  INVALID_ENV = 1,\n\n  // 100 - 199: Custom Elements Errors\n  DUPE_TAGNAME = 100,\n  INVALID_TAGNAME = 101,\n\n  // 200 - 299: Template Errors\n  TEMPLATE_INVALID = 200,\n  TEMPLATE_INVALID_NOTATION = 201,\n  TEMPLATE_INVALID_COMPONENT = 202,\n  TEMPLATE_INVALID_LIST = 203,\n  TEMPLATE_INVALID_NODE_REF = 204,\n  TEMPLATE_MISSING_LIST_PARENT = 205,\n  TEMPLATE_MISSING_LIST_KEY = 206,\n  TEMPLATE_DUPLICATE_LIST_KEY = 207,\n\n  // 300 - 399: Runtime Errors\n  MISSING_ELEMENT = 300,\n  MISSING_STATE = 301,\n  INVALID_CONTENT = 302,\n  INVALID_STATE_KEY = 303,\n  INVALID_STATE_UPDATE = 304,\n  STATE_LOCKED = 305,\n  MAX_SEQUENTIAL_RENDERS = 306,\n}\n\nfunction getDevError(code: ErrorCode) {\n  const DEV_ERROR_INFO: Record<ErrorCode, string> = {\n    [ErrorCode.INVARIANT]: `\nINVARIANT\nA condition has occurred which should never happen, such as a code path that\nshouldn't be reachable when using correct types, or a disallowed state.\n`,\n\n    [ErrorCode.INVALID_ENV]: `\nINVALID_ENV\nFailed to find a custom elements registry in this environment. Is a window\nglobal available with a customElements property?\n`,\n\n    [ErrorCode.DUPE_TAGNAME]: `\nDUPE_TAGNAME\nFailed to register a custom element with the tagname %s because another\ncustom element is already defined with that name.\n`,\n\n    [ErrorCode.INVALID_TAGNAME]: `\nINVALID_TAGNAME\nFailed to determine a valid HTML Tag to use when registering a component as a\ncustom element. Specify a static readonly tagName property on your component\nclass or provide a tagName argument to Component.register.\n\nAlternatively, you can directly register your element as you would any other\nHTML custom element: customElements.define(\"my-tag\", MyComponentClass);\n`,\n\n    [ErrorCode.MISSING_ELEMENT]: `\nMISSING_ELEMENT\nAn element was expected to exist but was not found when the DOM was queried.\n`,\n\n    [ErrorCode.MISSING_STATE]: `\nMISSING_STATE\nA Component's reactive state was accessed, but no initialState is defined for\nthe Component's class. Initial state must be defined as an object or function.\n`,\n\n    [ErrorCode.INVALID_CONTENT]: `\nINVALID_CONTENT\nTried to set a value as content in a template, but the value was not a supported\ntype. Values must be a string, HTMLElement.\n\nInstead, got %s: %s.\n`,\n\n    [ErrorCode.TEMPLATE_INVALID]: `\nTEMPLATE_INVALID\nThe value %s cannot be interpolated via the Template html string helper.\nValues may only be HTMLTemplateElements (template content is adopted) or\nstrings (shorthand for a ::swap directive on an element)\n`,\n\n    [ErrorCode.TEMPLATE_INVALID_NOTATION]: `\nTEMPLATE_INVALID_NOTATION\nA template value notation failed to parse. Notations must begin with one of\n@, $, *, or #, followed by a dot-separated path of accessor names. Optionally,\nnotations may have modifiers around them, such as the NOT() modifier.\n\nThe notation that failed to parse was \"%s\"\n`,\n    [ErrorCode.TEMPLATE_INVALID_COMPONENT]: `\nTEMPLATE_INVALID_COMPONENT\nFailed to interpolate a Component in an html template string due to the\nComponent having an invalid tagName property.\n\nComponent \"%s\" has an invalid tagName property \"%s\"\n    `,\n\n    [ErrorCode.TEMPLATE_MISSING_LIST_PARENT]: `\nTEMPLATE_MISSING_LIST_PARENT\nA template failed to prepare an ::each directive because no valid parent node\nwas found for the list to render into.\n`,\n\n    [ErrorCode.TEMPLATE_INVALID_LIST]: `\nTEMPLATE_INVALID_LIST\nA template failed to render because an ::each directive fetched a value which\nwas not an array of actionable data.\n`,\n\n    [ErrorCode.TEMPLATE_INVALID_NODE_REF]: `\nTEMPLATE_INVALID_NODE_REF\nA template failed to prepare a node from a compiled source. Typically, this\nmeans something is broken within the compiled template rather than an error with\nthe template content itself.\n`,\n\n    [ErrorCode.TEMPLATE_MISSING_LIST_KEY]: `\nTEMPLATE_MISSING_LIST_KEY\nA template failed to compile because an ::each directive was found on an element\nwithout a corresponding ::key directive. ::each directives must have a ::key\ndirective specified on the same element, whose notation evaluates to a unique\nvalue for each item in the list.\n\nExample: <li ::each=\"$items\" ::key=\"#id\"> ... </li>\n`,\n\n    [ErrorCode.TEMPLATE_DUPLICATE_LIST_KEY]: `\nTEMPLATE_DUPLICATE_LIST_KEY\nA list failed to render because item key %s appeared multiple times when\nresolving list item keys. Each ::key directive must reference a notation whose\nvalue is unique for each list item.\n`,\n\n    [ErrorCode.INVALID_STATE_KEY]: `\nINVALID_STATE_KEY\nTried to access a state property which does not exist\n\nKey path: %s\n`,\n\n    [ErrorCode.INVALID_STATE_UPDATE]: `\nINVALID_STATE_UPDATE\nA Component's setState() was called with a value which could not be patched in\nto the existing component state.\n\nsetState() takes a partial object describing state keys to update.\n\nInstead, received: %s\n`,\n\n    [ErrorCode.STATE_LOCKED]: `\nSTATE_LOCKED\nA State received a request to update or lock while already locked.\nStates may be locked using the .lock() method and unlocked using the .unlock()\nmethod. States lock during async mutations done through the .mutateAsync()\nmethod if \"true\" is passed as the second parameter.\n\nYou can check the lock status of a State instance with .isLocked\n`,\n\n    [ErrorCode.MAX_SEQUENTIAL_RENDERS]: `\nMAX_SEQUENTIAL_RENDERS\nA component has errored after re-rendering more than %s times in the same frame.\n\nThis typically happens because state or live attributes are being modified\nduring a render lifecycle method such as beforeUpdate() or afterUpdate(). If\nstate changes unconditionally during a render, the render will infinitely loop.\nUpdating render source data during a render cycle is supported, but infinite\nupdate loops may occur if unchecked.\n`,\n  };\n\n  return DEV_ERROR_INFO[code];\n}\n\n/**\n * An error originating from within a Palette subsystem.\n *\n * In the `development` environment, the error will surface with extended info\n * about the error and any details which may be relevant to help with debugging.\n *\n * In the `production` environment, a minimal error only surfacing the numeric\n * error code is thrown instead.\n *\n * Codes are categorized into groups by the 100's:\n *\n * - 0 - 99: Invariants\n * - 100 - 199: Custom Elements / Environment Errors\n * - 200 - 299: Templating Errors\n * - 300 - 399: Runtime Errors\n */\nexport class PaletteError extends Error {\n  name = \"PaletteError\";\n  code: number;\n\n  constructor(code: number, ...values: string[]) {\n    let message = `Code: ${code}`;\n    if (__DEV__) {\n      message += getDevError(code);\n\n      for (const val of values) {\n        message = message.replace(`%s`, String(val));\n      }\n    }\n\n    super(message);\n    this.code = code;\n  }\n}\n",
    "/*\n * Copyright © Rustic Arcade, LLC 2026\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\nimport { ErrorCode, PaletteError } from \"#error\";\n\n/** An attribute value as read from a DOM element */\ntype AttributeValue = string | null;\n\n/** A Map of string attribute names to {@link AttributeValue} */\ntype AttributeMap = Map<string, AttributeValue>;\n\nexport function serializeAttribute(value: unknown): AttributeValue {\n  if (typeof value === \"string\" || typeof value === \"number\") {\n    return `${value}`;\n  }\n\n  if (value === true) {\n    return \"\";\n  }\n\n  if (value === null || value === false || value === undefined) {\n    return null;\n  }\n\n  return value.toString();\n}\n\nexport function createAttributeMap(\n  source: object | Map<string, unknown> | HTMLElement,\n): AttributeMap {\n  const map = new Map<string, string | null>();\n\n  if (source instanceof HTMLElement) {\n    for (const name of source.getAttributeNames()) {\n      map.set(name, serializeAttribute(source.getAttribute(name)));\n    }\n    return map;\n  }\n\n  if (source instanceof Map) {\n    for (const [key, val] of source) {\n      map.set(key, serializeAttribute(val));\n    }\n    return map;\n  }\n\n  if (typeof source === \"object\" && source !== null) {\n    for (const [key, val] of Object.entries(source)) {\n      map.set(key, serializeAttribute(val));\n    }\n    return map;\n  }\n\n  throw new PaletteError(ErrorCode.INVARIANT);\n}\n\nexport function applyAttributeMap(\n  target: HTMLElement,\n  attrs: AttributeMap,\n): void {\n  const currentNames = new Set(target.getAttributeNames());\n  const incomingNames = new Set(attrs.keys());\n  const attributesToRemove = currentNames.difference(incomingNames);\n\n  for (const attr of attributesToRemove) {\n    target.removeAttribute(attr);\n  }\n\n  for (const [name, val] of attrs) {\n    if (val === null) {\n      target.removeAttribute(name);\n    } else {\n      target.setAttribute(name, val);\n    }\n  }\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\ntype Metrics = {\n  hits: number;\n  misses: number;\n};\n\nexport type LRUCacheMetrics = {\n  lookups: number;\n  hits: number;\n  misses: number;\n  capacity: number;\n  entries: number;\n  hitRate: number;\n};\n\n/**\n * A simple in-memory LRU Cache using JavaScript maps.\n *\n * @example\n *\n * Cached network request\n *\n * ```typescript\n * // A cache of API URLs to their returned payloads\n * const cache = new LRUCache<string, APIPayload>();\n *\n * async function makeRequest(url: string) {\n *   let cached = cache.get(url);\n *   if (cached) {\n *     return cached;\n *   }\n *\n *   // ... Make the request and cache.set() the response\n * }\n * ```\n */\nexport class LRUCache<K, V> {\n  private _maxSize: number;\n  private _data: Map<K, V>;\n  private _metrics: Metrics = { hits: 0, misses: 0 };\n\n  constructor(maxSize: number = 500) {\n    if (maxSize <= 0) {\n      throw new Error(\"LRU Cache capacity must be >= 1\");\n    }\n\n    if (__DEV__) {\n      this._metrics = { hits: 0, misses: 0 };\n    }\n\n    this._maxSize = maxSize;\n    this._data = new Map<K, V>();\n  }\n\n  private _trim = () => {\n    while (this._data.size > this._maxSize) {\n      const firstKey = this._data.keys().next().value;\n      if (firstKey === undefined) {\n        throw new Error(\"Absurd\");\n      }\n      this._data.delete(firstKey);\n    }\n  };\n\n  /**\n   * Get cache performance metrics from this LRU Cache instance.\n   *\n   * In development mode, this returns insights into hits/misses of the cache,\n   * as well as the current configuration and entry count.\n   *\n   * In production mode, this returns a placeholder object, as metric collection\n   * is not active in production.\n   */\n  get metrics(): LRUCacheMetrics {\n    if (__DEV__) {\n      const { hits = 0, misses = 0 } = this._metrics ?? {};\n      const lookups = hits + misses;\n      const hitRate = lookups === 0 ? 0 : hits / lookups;\n\n      return {\n        lookups,\n        hits: hits,\n        misses: misses,\n        capacity: this._maxSize,\n        entries: this._data.size,\n        hitRate,\n      };\n    }\n\n    return {\n      lookups: 0,\n      hits: 0,\n      misses: 0,\n      capacity: 0,\n      entries: 0,\n      hitRate: 0,\n    };\n  }\n\n  /**\n   * Update the maximum cache size for this instance. Immediately triggers a\n   * purge of cached contents if the new capacity is less than the current\n   * number of cached entries.\n   */\n  setCapacity = (maxSize: number): void => {\n    if (maxSize <= 0 && __DEV__) {\n      console.warn(\n        \"[Palette LRU Cache] Cache size is <= 0. Cache is disabled.\",\n      );\n    }\n\n    this._maxSize = maxSize;\n    this._trim();\n  };\n\n  /**\n   * Fetch a value from the cache, returning `undefined` if no value was found\n   */\n  get(key: K): V | undefined {\n    const value = this._data.get(key);\n\n    if (value === undefined) {\n      if (__DEV__) {\n        this._metrics.misses += 1;\n      }\n      return undefined;\n    }\n\n    // Delete and re-set the value to move the key to the end of the key list\n    this._data.delete(key);\n    this._data.set(key, value);\n\n    if (__DEV__) {\n      this._metrics.hits += 1;\n    }\n\n    return value;\n  }\n\n  /**\n   * Set a value in the cache. This also moves the value to the back of the list\n   * of values to consider evicting when the cache is full.\n   */\n  set(key: K, value: V): void {\n    // Remove if exists to update position\n    if (this._data.has(key)) {\n      this._data.delete(key);\n    }\n\n    this._data.set(key, value);\n\n    if (this._data.size > this._maxSize) {\n      this._trim();\n    }\n  }\n\n  /**\n   * Clear all contents of this cache instance\n   */\n  clear(): void {\n    this._data.clear();\n  }\n\n  /**\n   * Get the number of entries in this cache instance\n   */\n  get size(): number {\n    return this._data.size;\n  }\n}\n\nexport default LRUCache;\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\nimport LRUCache from \"./lru-cache\";\n\nexport const fragmentCache = new LRUCache<string, DocumentFragment>();\n\nexport function htmlToFragment(html: string): DocumentFragment {\n  const lookup = fragmentCache.get(html);\n\n  if (lookup !== undefined) {\n    return lookup.cloneNode(true) as DocumentFragment;\n  }\n\n  const temp = document.createElement(\"template\");\n  temp.innerHTML = html;\n  fragmentCache.set(html, temp.content);\n  return temp.content.cloneNode(true) as DocumentFragment;\n}\n",
    "/*\n * Copyright © Rustic Arcade, LLC 2026\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\n/**\n * Returns a random tag name for use in a test element\n */\nexport const randomTagName = () => {\n  const id = crypto.randomUUID().replaceAll(\"-\", \"\").slice(0, 10);\n  return `test-element-${id}`;\n};\n",
    "/*\n * Copyright © Rustic Arcade, LLC 2026\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\nimport type { Component } from \"#component\";\nimport { applyAttributeMap, createAttributeMap } from \"#util\";\nimport { randomTagName } from \"./tags\";\n\n/**\n * Render a Palette Component class as a test element\n *\n * If the class is not yet registered, it is auto-registered before creation.\n *\n * @example\n *\n * ```typescript\n * test(\"component does something\", async () => {\n *   let somethingMock = mock();\n *\n *   class MyTestComponent extends Component {\n *     script() {\n *       somethingMock();\n *     }\n *   }\n *\n *   await renderTestComponent(MyTestComponent);\n *   expect(somethingMock).toHaveBeenCalled();\n * });\n * ```\n *\n * @param component The component class to register and create\n * @param attributes A record of attributes to apply\n * @returns A reference to the rendered Component\n */\nexport async function renderTestComponent<E extends typeof Component<any>>(\n  component: E,\n  attributes?: Record<string, unknown>,\n): Promise<InstanceType<E>> {\n  // Error early if misconfigured\n  if (\n    typeof window === \"undefined\" ||\n    typeof window.customElements === \"undefined\"\n  ) {\n    throw new Error(\n      \"Failed to render test component: \" +\n        \"window.customElements is not available in this environment.\",\n    );\n  }\n\n  const useTagname =\n    component.tagName === \"\" ? randomTagName() : component.tagName;\n\n  // Reassign the tagname back to the component to ensure it is set before registration\n  component.tagName = useTagname;\n\n  // Register the component if need be\n  if (!customElements.get(useTagname)) {\n    customElements.define(\n      useTagname,\n      component as unknown as CustomElementConstructor,\n    );\n  }\n\n  // Construct a test instance\n  const $component = document.createElement(component.tagName);\n\n  // Apply attributes before rendering\n  const attributeMap = createAttributeMap(attributes ?? {});\n  applyAttributeMap($component, attributeMap);\n\n  // Render and await to allow microtasks to settle\n  document.body.append($component);\n  await Bun.sleep(1);\n\n  // Return the rendered instance\n  return $component as InstanceType<E>;\n}\n\n/**\n * Force a render on the target element\n *\n * Returns a promise which resolves when the render has completed\n */\nexport async function rerenderTestComponent(element: Component): Promise<void> {\n  return new Promise((resolve) => {\n    element.requestRender(async () => {\n      await Bun.sleep(1);\n      resolve();\n    });\n  });\n}\n"
  ],
  "mappings": "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",
  "debugId": "925A43921950535764756E2164756E21",
  "names": []
}

package/package.json

@@ -1,13 +1,38 @@
 {
   "name": "@rusticarcade/palette",
+  "version": "0.3.1",
   "description": "Native web development, but make it joyful",
-  "version": "0.2.0",
-  "type": "module",
+  "keywords": [
+    "palette",
+    "component",
+    "web components",
+    "template",
+    "state",
+    "ui",
+    "framework"
+  ],
+  "homepage": "https://palette.camp",
+  "bugs": {
+    "url": "https://git.astral.camp/rusticarcade/palette/issues",
+    "email": "palette@endeavorance.camp"
+  },
+  "license": "MPL-2.0",
+  "author": {
+    "name": "endeavorance",
+    "url": "https://endeavorance.camp",
+    "email": "hello@endeavorance.camp"
+  },
+  "funding": [
+    {
+      "type": "patreon",
+      "url": "https://patreon.com/endeavorance"
+    }
+  ],
   "files": [
     "dist/prod",
-    "dist/dev"
+    "dist/dev",
+    "dist/test"
   ],
-  "types": "./dist/prod/index.d.ts",
   "exports": {
     ".": {
       "import": {
@@ -17,14 +42,16 @@
         "default": "./dist/prod/index.js"
       }
     },
+    "./test": {
+      "import": {
+        "types": "./dist/test/index.d.ts",
+        "default": "./dist/test/index.js"
+      }
+    },
     "./package.json": "./package.json"
   },
-  "license": "MPL-2.0",
-  "author": {
-    "name": "endeavorance",
-    "url": "https://endeavorance.camp",
-    "email": "hello@endeavorance.camp"
-  },
+  "type": "module",
+  "types": "./dist/prod/index.d.ts",
   "repository": {
     "type": "git",
     "url": "https://git.astral.camp/rusticarcade/palette"