@ecopages/radiant 0.1.4 → 0.1.6

package/dist/decorators/reactive-prop.js

@@ -1,4 +1,215 @@
-import{o as J,p as L,q as M,r as N} from"../utils/attribute-utils.js";function Y({type:k,attribute:Q,reflect:R,defaultValue:B}){if(B!==void 0&&!N(k,B))throw new Error(`defaultValue does not match the expected type for ${k.name}`);return(H,C)=>{const q=new WeakMap,D=`__${C}`,G=Q??C,S=(j)=>{if(k===Boolean)return j.hasAttribute(G)||B;const z=j.getAttribute(G);return z!==null?L(z,k):B||J(k)};Object.defineProperty(H,D,{get:function(){if(!q.has(this)){const j=S(this);q.set(this,j)}return q.get(this)},set:function(j){const z=q.get(this);if(z===j)return;if(q.set(this,j),R)this.setAttribute(G,M(j,k));this.updated(C,z,j)},enumerable:!0,configurable:!0}),Object.defineProperty(H,C,{get:function(){return this[D]},set:function(j){this[D]=j},enumerable:!0,configurable:!0})}}export{Y as reactiveProp};
-export{Y as w};
+// src/utils/attribute-utils.ts
+function parseAttributeTypeConstant(constant) {
+  switch (constant) {
+    case Array:
+      return "array";
+    case Boolean:
+      return "boolean";
+    case Number:
+      return "number";
+    case Object:
+      return "object";
+    case String:
+      return "string";
+  }
+}
+function parseAttributeTypeDefault(defaultValue) {
+  switch (typeof defaultValue) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+  }
+  if (Array.isArray(defaultValue))
+    return "array";
+  if (Object.prototype.toString.call(defaultValue) === "[object Object]")
+    return "object";
+}
+function defaultValueForType(type) {
+  switch (type) {
+    case Number:
+      return 0;
+    case String:
+      return "";
+    case Boolean:
+      return false;
+    default:
+      return null;
+  }
+}
+function parseJSON(value) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new TypeError("Invalid JSON string");
+  }
+}
+function writeJSON(value) {
+  return JSON.stringify(value);
+}
+function writeString(value) {
+  return `${value}`;
+}
+function readAttributeValue(value, type) {
+  const readerType = parseAttributeTypeConstant(type);
+  if (!readerType)
+    throw new TypeError(`[radiant-element] Unknown type "${type}"`);
+  return readers[readerType](value);
+}
+function writeAttributeValue(value, type) {
+  const writerType = parseAttributeTypeConstant(type);
+  if (!writerType)
+    throw new TypeError(`[radiant-element] Unknown type "${type}"`);
+  return (writers[writerType] || writers.default)(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isObject(value) {
+  return typeof value === "object" && !Array.isArray(value) && value !== null;
+}
+function isValueOfType(type, defaultValue) {
+  switch (type) {
+    case Boolean:
+      return isBoolean(defaultValue);
+    case Number:
+      return isNumber(defaultValue);
+    case String:
+      return isString(defaultValue);
+    case Array:
+      return isArray(defaultValue);
+    case Object:
+      return isObject(defaultValue);
+    default:
+      return false;
+  }
+}
+var readers = {
+  array(value) {
+    const array = parseJSON(value);
+    if (!Array.isArray(array)) {
+      throw new TypeError(`Expected an array but got a value of type "${typeof array}"`);
+    }
+    return array;
+  },
+  boolean(value) {
+    return !(value === "0" || String(value).toLowerCase() === "false");
+  },
+  number(value) {
+    const number = Number(value.replace(/_/g, ""));
+    return number;
+  },
+  object(value) {
+    const object = JSON.parse(value);
+    if (object === null || typeof object !== "object" || Array.isArray(object)) {
+      throw new TypeError(`expected value of type "object" but instead got value "${value}" of type "${parseAttributeTypeDefault(object)}"`);
+    }
+    return object;
+  },
+  string(value) {
+    return value;
+  }
+};
+var writers = {
+  default: writeString,
+  array: writeJSON,
+  object: writeJSON
+};
 
-//# debugId=D94321FDF9DD649064756E2164756E21
+// src/decorators/reactive-prop.ts
+function reactiveProp({ type, attribute, reflect, defaultValue }) {
+  if (defaultValue !== undefined && !isValueOfType(type, defaultValue)) {
+    throw new Error(`defaultValue does not match the expected type for ${type.name}`);
+  }
+  return (target, propertyName) => {
+    const originalValues = new WeakMap;
+    const attributeKey = attribute ?? propertyName;
+    if (propertyName in target) {
+      throw new Error(`Property "${propertyName}" already exists on ${target.constructor.name}`);
+    }
+    const propertyMapping = {
+      type,
+      propertyName,
+      attributeKey,
+      converter: {
+        fromAttribute: (value) => readAttributeValue(value, type),
+        toAttribute: (value) => writeAttributeValue(value, type)
+      }
+    };
+    addPropertyToMappings(target, propertyMapping);
+    Object.defineProperty(target, propertyName, {
+      get: function() {
+        if (!originalValues.has(this)) {
+          const initialValue = getInitialValue(this, type, attributeKey, defaultValue);
+          originalValues.set(this, initialValue);
+        }
+        return originalValues.get(this);
+      },
+      set: function(newValue) {
+        const oldValue = originalValues.get(this);
+        if (oldValue === newValue)
+          return;
+        originalValues.set(this, newValue);
+        if (reflect) {
+          const attributeValue = propertyMapping.converter.toAttribute(newValue);
+          this.setAttribute(attributeKey, attributeValue);
+        }
+        this.updated(propertyName, oldValue, newValue);
+      },
+      enumerable: true,
+      configurable: true
+    });
+    const originalConnectedCallback = target.connectedCallback;
+    target.connectedCallback = function() {
+      originalConnectedCallback.call(this);
+      this.updated(propertyName, null, defaultValue);
+    };
+    addObservedAttribute(target, attributeKey);
+  };
+}
+function addObservedAttribute(target, attribute) {
+  const ctor = target.constructor;
+  const existingObservedAttributes = ctor.observedAttributes || [];
+  if (!existingObservedAttributes.includes(attribute)) {
+    const newObservedAttributes = [...existingObservedAttributes, attribute];
+    Object.defineProperty(ctor, "observedAttributes", {
+      get() {
+        return newObservedAttributes;
+      },
+      configurable: true
+    });
+  }
+}
+var getInitialValue = (target, type, attributeKey, defaultValue) => {
+  if (type === Boolean) {
+    const hasAttribute = target.hasAttribute(attributeKey);
+    return hasAttribute || defaultValue;
+  }
+  const attributeValue = target.getAttribute(attributeKey);
+  return attributeValue !== null ? readAttributeValue(attributeValue, type) : defaultValue || defaultValueForType(type);
+};
+var addPropertyToMappings = (target, propertyMapping) => {
+  if (!("propertyConfigMap" in target)) {
+    Object.defineProperty(target, "propertyConfigMap", {
+      value: new Map,
+      configurable: true
+    });
+  }
+  target.propertyConfigMap.set(propertyMapping.propertyName, propertyMapping);
+};
+export {
+  reactiveProp
+};
+
+//# debugId=1F23EE7729F124F364756E2164756E21

package/dist/decorators/reactive-prop.js.map

@@ -1,10 +1,11 @@
 {
   "version": 3,
-  "sources": ["../src/decorators/reactive-prop.ts"],
+  "sources": ["../src/utils/attribute-utils.ts", "../src/decorators/reactive-prop.ts"],
   "sourcesContent": [
-    "import type { RadiantElement } from '@/core/radiant-element';\nimport {\n  type AttributeTypeConstant,\n  defaultValueForType,\n  isValueOfType,\n  readAttributeValue,\n  writeAttributeValue,\n} from '@/utils/attribute-utils';\n\ntype ReactivePropertyOptions<T> = {\n  type: AttributeTypeConstant;\n  reflect?: boolean;\n  attribute?: string;\n  defaultValue?: T;\n};\n\n/**\n * A decorator to define a reactive property.\n * Every time the property changes, the `updated` method will be called.\n * @param options The options for the reactive property.\n * @param options.type The type of the property value.\n * @param options.reflect Whether to reflect the property to the attribute.\n * @param options.attribute The name of the attribute.\n * @param options.defaultValue The default value of the property.\n */\nexport function reactiveProp<T = unknown>({ type, attribute, reflect, defaultValue }: ReactivePropertyOptions<T>) {\n  if (defaultValue !== undefined && !isValueOfType(type, defaultValue)) {\n    throw new Error(`defaultValue does not match the expected type for ${type.name}`);\n  }\n\n  return (proto: RadiantElement, propertyKey: string) => {\n    const originalValues = new WeakMap<WeakKey, unknown>();\n    const prefixedPropertyKey = `__${propertyKey}`;\n    const attributeKey = attribute ?? propertyKey;\n\n    const getInitialValue = (context: RadiantElement) => {\n      if (type === Boolean) {\n        const hasAttribute = context.hasAttribute(attributeKey);\n        return hasAttribute || defaultValue;\n      }\n\n      const attributeValue = context.getAttribute(attributeKey);\n      return attributeValue !== null\n        ? readAttributeValue(attributeValue, type)\n        : defaultValue || defaultValueForType(type);\n    };\n\n    Object.defineProperty(proto, prefixedPropertyKey, {\n      get: function () {\n        if (!originalValues.has(this)) {\n          const initialValue = getInitialValue(this);\n          originalValues.set(this, initialValue);\n        }\n        return originalValues.get(this);\n      },\n      set: function (newValue: T) {\n        const oldValue = originalValues.get(this);\n        if (oldValue === newValue) return;\n        originalValues.set(this, newValue);\n        if (reflect) this.setAttribute(attributeKey, writeAttributeValue(newValue, type));\n        this.updated(propertyKey, oldValue, newValue);\n      },\n      enumerable: true,\n      configurable: true,\n    });\n\n    Object.defineProperty(proto, propertyKey, {\n      get: function () {\n        return this[prefixedPropertyKey];\n      },\n      set: function (newValue: string) {\n        this[prefixedPropertyKey] = newValue;\n      },\n      enumerable: true,\n      configurable: true,\n    });\n  };\n}\n"
+    "export type AttributeTypeConstant = typeof Array | typeof Boolean | typeof Number | typeof Object | typeof String;\n\nexport type AttributeTypeDefault = Array<unknown> | boolean | number | Record<string, unknown> | string;\n\n/**\n * Parses the given attribute type constant and returns its corresponding string representation.\n *\n * @param constant - The attribute type constant to parse.\n * @returns The string representation of the attribute type constant.\n */\nexport function parseAttributeTypeConstant(constant?: AttributeTypeConstant) {\n  switch (constant) {\n    case Array:\n      return 'array';\n    case Boolean:\n      return 'boolean';\n    case Number:\n      return 'number';\n    case Object:\n      return 'object';\n    case String:\n      return 'string';\n  }\n}\n\n/**\n * Parses the attribute type default value and returns its type as a string.\n *\n * @param defaultValue - The default value of the attribute type.\n * @returns The type of the default value as a string.\n */\nexport function parseAttributeTypeDefault(defaultValue?: AttributeTypeDefault) {\n  switch (typeof defaultValue) {\n    case 'boolean':\n      return 'boolean';\n    case 'number':\n      return 'number';\n    case 'string':\n      return 'string';\n  }\n\n  if (Array.isArray(defaultValue)) return 'array';\n  if (Object.prototype.toString.call(defaultValue) === '[object Object]') return 'object';\n}\n\n/**\n * Returns the default value for a given attribute type.\n *\n * @param type - The attribute type constant.\n * @returns The default value for the specified attribute type.\n */\nexport function defaultValueForType(type: AttributeTypeConstant): unknown {\n  switch (type) {\n    case Number:\n      return 0;\n    case String:\n      return '';\n    case Boolean:\n      return false;\n    default:\n      return null;\n  }\n}\n\ntype Reader = (value: string) => number | string | boolean | object | unknown[];\n\n/**\n * Utility function to parse a JSON string safely\n */\nfunction parseJSON<T>(value: string): T {\n  try {\n    return JSON.parse(value);\n  } catch (error) {\n    throw new TypeError('Invalid JSON string');\n  }\n}\n\n/**\n * Object that maps attribute types to reader functions.\n * @type {Object.<string, Reader>}\n */\nconst readers: { [type: string]: Reader } = {\n  array(value: string): unknown[] {\n    const array = parseJSON<unknown[]>(value);\n    if (!Array.isArray(array)) {\n      throw new TypeError(`Expected an array but got a value of type \"${typeof array}\"`);\n    }\n    return array;\n  },\n\n  boolean(value: string): boolean {\n    return !(value === '0' || String(value).toLowerCase() === 'false');\n  },\n\n  number(value: string): number {\n    const number = Number(value.replace(/_/g, ''));\n    return number;\n  },\n\n  object(value: string): object {\n    const object = JSON.parse(value);\n    if (object === null || typeof object !== 'object' || Array.isArray(object)) {\n      throw new TypeError(\n        `expected value of type \"object\" but instead got value \"${value}\" of type \"${parseAttributeTypeDefault(\n          object,\n        )}\"`,\n      );\n    }\n    return object;\n  },\n\n  string(value: string): string {\n    return value;\n  },\n};\n\ntype Writer = (value: unknown) => string;\n\n/**\n * Object that maps attribute types to writer functions.\n * @type {Object.<string, Writer>}\n */\nconst writers: { [type: string]: Writer } = {\n  default: writeString,\n  array: writeJSON,\n  object: writeJSON,\n};\n\nfunction writeJSON(value: unknown) {\n  return JSON.stringify(value);\n}\n\nfunction writeString(value: unknown) {\n  return `${value}`;\n}\n\n/**\n * Reads the attribute value based on the provided type.\n * @param value - The attribute value to be read.\n * @param type - The type of the attribute.\n * @returns The parsed attribute value.\n * @throws {TypeError} If the provided type is unknown.\n */\nexport function readAttributeValue(value: string, type: AttributeTypeConstant) {\n  const readerType = parseAttributeTypeConstant(type);\n  if (!readerType) throw new TypeError(`[radiant-element] Unknown type \"${type}\"`);\n  return readers[readerType](value);\n}\n\nexport type ReadAttributeValueReturnType = ReturnType<typeof readAttributeValue>;\n\n/**\n * Writes the attribute value based on the provided type.\n *\n * @param value - The value to be written.\n * @param type - The type of the attribute.\n * @returns The written attribute value.\n * @throws {TypeError} If the provided type is unknown.\n */\nexport function writeAttributeValue(value: unknown, type: AttributeTypeConstant) {\n  const writerType = parseAttributeTypeConstant(type);\n  if (!writerType) throw new TypeError(`[radiant-element] Unknown type \"${type}\"`);\n  return (writers[writerType] || writers.default)(value);\n}\n\nexport type WriteAttributeValueReturnType = ReturnType<typeof writeAttributeValue>;\n\n/*\n * Type guard functions for each type in AttributeTypeConstant\n */\nfunction isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean';\n}\n\nfunction isNumber(value: unknown): value is number {\n  return typeof value === 'number';\n}\n\nfunction isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n\nfunction isArray(value: unknown): value is Array<unknown> {\n  return Array.isArray(value);\n}\n\nfunction isObject(value: unknown): value is object {\n  return typeof value === 'object' && !Array.isArray(value) && value !== null;\n}\n\n/*\n * Check function to ensure defaultValue matches the type\n */\nexport function isValueOfType(type: AttributeTypeConstant, defaultValue: unknown): boolean {\n  switch (type) {\n    case Boolean:\n      return isBoolean(defaultValue);\n    case Number:\n      return isNumber(defaultValue);\n    case String:\n      return isString(defaultValue);\n    case Array:\n      return isArray(defaultValue);\n    case Object:\n      return isObject(defaultValue);\n    default:\n      return false;\n  }\n}\n",
+    "import type { PropertyConfig, RadiantElement } from '@/core/radiant-element';\nimport {\n  type AttributeTypeConstant,\n  defaultValueForType,\n  isValueOfType,\n  readAttributeValue,\n  writeAttributeValue,\n} from '@/utils/attribute-utils';\n\ntype ReactivePropertyOptions<T> = {\n  type: AttributeTypeConstant;\n  reflect?: boolean;\n  attribute?: string;\n  defaultValue?: T;\n};\n\n/**\n * A decorator to define a reactive property.\n * Every time the property changes, the `updated` method will be called.\n * @param options The options for the reactive property.\n * @param options.type The type of the property value.\n * @param options.reflect Whether to reflect the property to the attribute.\n * @param options.attribute The name of the attribute.\n * @param options.defaultValue The default value of the property.\n */\nexport function reactiveProp<T = unknown>({ type, attribute, reflect, defaultValue }: ReactivePropertyOptions<T>) {\n  if (defaultValue !== undefined && !isValueOfType(type, defaultValue)) {\n    throw new Error(`defaultValue does not match the expected type for ${type.name}`);\n  }\n\n  return (target: RadiantElement, propertyName: string) => {\n    const originalValues = new WeakMap<WeakKey, unknown>();\n    const attributeKey = attribute ?? propertyName;\n\n    if (propertyName in target) {\n      throw new Error(`Property \"${propertyName}\" already exists on ${target.constructor.name}`);\n    }\n\n    const propertyMapping: PropertyConfig = {\n      type,\n      propertyName,\n      attributeKey,\n      converter: {\n        fromAttribute: (value) => readAttributeValue(value, type),\n        toAttribute: (value) => writeAttributeValue(value, type),\n      },\n    };\n\n    addPropertyToMappings(target, propertyMapping);\n\n    Object.defineProperty(target, propertyName, {\n      get: function () {\n        if (!originalValues.has(this)) {\n          const initialValue = getInitialValue(this, type, attributeKey, defaultValue as T);\n          originalValues.set(this, initialValue);\n        }\n        return originalValues.get(this);\n      },\n      set: function (newValue: T) {\n        const oldValue = originalValues.get(this);\n        if (oldValue === newValue) return;\n        originalValues.set(this, newValue);\n        if (reflect) {\n          const attributeValue = propertyMapping.converter.toAttribute(newValue);\n          this.setAttribute(attributeKey, attributeValue);\n        }\n        this.updated(propertyName, oldValue, newValue);\n      },\n      enumerable: true,\n      configurable: true,\n    });\n\n    const originalConnectedCallback = target.connectedCallback;\n\n    target.connectedCallback = function (this: RadiantElement) {\n      originalConnectedCallback.call(this);\n      this.updated(propertyName, null, defaultValue);\n    };\n\n    addObservedAttribute(target, attributeKey);\n  };\n}\n\nconst getInitialValue = (\n  target: RadiantElement,\n  type: AttributeTypeConstant,\n  attributeKey: string,\n  defaultValue: unknown,\n) => {\n  if (type === Boolean) {\n    const hasAttribute = target.hasAttribute(attributeKey);\n    return hasAttribute || defaultValue;\n  }\n\n  const attributeValue = target.getAttribute(attributeKey);\n  return attributeValue !== null\n    ? readAttributeValue(attributeValue, type)\n    : defaultValue || (defaultValueForType(type) as typeof defaultValue);\n};\n\nconst addPropertyToMappings = (target: RadiantElement, propertyMapping: PropertyConfig) => {\n  if (!('propertyConfigMap' in target)) {\n    Object.defineProperty(target, 'propertyConfigMap', {\n      value: new Map<string, PropertyConfig>(),\n      configurable: true,\n    });\n  }\n\n  target.propertyConfigMap.set(propertyMapping.propertyName, propertyMapping);\n};\n\nfunction addObservedAttribute(target: RadiantElement, attribute: string) {\n  const ctor = target.constructor as typeof RadiantElement;\n  const existingObservedAttributes = (ctor as any).observedAttributes || [];\n  if (!existingObservedAttributes.includes(attribute)) {\n    const newObservedAttributes = [...existingObservedAttributes, attribute];\n    Object.defineProperty(ctor, 'observedAttributes', {\n      get() {\n        return newObservedAttributes;\n      },\n      configurable: true,\n    });\n  }\n}\n"
   ],
-  "mappings": "sEAyBO,SAAS,CAAyB,EAAG,OAAM,YAAW,UAAS,gBAA4C,CAChH,GAAI,IAAiB,SAAc,EAAc,EAAM,CAAY,EACjE,MAAM,IAAI,MAAM,qDAAqD,EAAK,MAAM,EAGlF,MAAO,CAAC,EAAuB,IAAwB,CACrD,MAAM,EAAiB,IAAI,QACrB,EAAsB,KAAK,IAC3B,EAAe,GAAa,EAE5B,EAAkB,CAAC,IAA4B,CACnD,GAAI,IAAS,QAEX,OADqB,EAAQ,aAAa,CAAY,GAC/B,EAGzB,MAAM,EAAiB,EAAQ,aAAa,CAAY,EACxD,OAAO,IAAmB,KACtB,EAAmB,EAAgB,CAAI,EACvC,GAAgB,EAAoB,CAAI,GAG9C,OAAO,eAAe,EAAO,EAAqB,CAChD,YAAc,EAAG,CACf,IAAK,EAAe,IAAI,IAAI,EAAG,CAC7B,MAAM,EAAe,EAAgB,IAAI,EACzC,EAAe,IAAI,KAAM,CAAY,EAEvC,OAAO,EAAe,IAAI,IAAI,GAEhC,YAAc,CAAC,EAAa,CAC1B,MAAM,EAAW,EAAe,IAAI,IAAI,EACxC,GAAI,IAAa,EAAU,OAE3B,GADA,EAAe,IAAI,KAAM,CAAQ,EAC7B,EAAS,KAAK,aAAa,EAAc,EAAoB,EAAU,CAAI,CAAC,EAChF,KAAK,QAAQ,EAAa,EAAU,CAAQ,GAE9C,WAAY,GACZ,aAAc,EAChB,CAAC,EAED,OAAO,eAAe,EAAO,EAAa,CACxC,YAAc,EAAG,CACf,OAAO,KAAK,IAEd,YAAc,CAAC,EAAkB,CAC/B,KAAK,GAAuB,GAE9B,WAAY,GACZ,aAAc,EAChB,CAAC",
-  "debugId": "D94321FDF9DD649064756E2164756E21",
+  "mappings": "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",
+  "debugId": "1F23EE7729F124F364756E2164756E21",
   "names": []
 }

package/dist/decorators.js

@@ -1,3 +1,401 @@
-import"./utils/attribute-utils.js";import"./tools/event-emitter.js";import{u as c} from"./decorators/on-event.js";import{v as b} from"./decorators/event.js";import{w as h} from"./decorators/reactive-prop.js";import{x as d} from"./decorators/on-updated.js";import{y as i} from"./decorators/reactive-field.js";import{z as g} from"./decorators/query.js";import{A as a} from"./decorators/custom-element.js";export{h as reactiveProp,i as reactiveField,g as query,d as onUpdated,c as onEvent,b as event,a as customElement};
+// src/decorators/custom-element.ts
+function customElement(name) {
+  return (target) => {
+    if (!globalThis.window)
+      return;
+    if (!window.customElements.get(name)) {
+      window.customElements.define(name, target);
+    }
+  };
+}
 
-//# debugId=71830EA449072B8A64756E2164756E21
+// src/tools/event-emitter.ts
+class EventEmitter {
+  host;
+  eventConfig;
+  constructor(host, eventConfig) {
+    this.host = host;
+    this.eventConfig = eventConfig;
+  }
+  emit(detail) {
+    const event = new CustomEvent(this.eventConfig.name, {
+      detail,
+      bubbles: this.eventConfig.bubbles,
+      cancelable: this.eventConfig.cancelable,
+      composed: this.eventConfig.composed
+    });
+    this.host.dispatchEvent(event);
+  }
+}
+
+// src/decorators/event.ts
+function event(eventConfig) {
+  return (target, propertyKey) => {
+    if (!propertyKey) {
+      throw new Error("The propertyKey is missing for the event decorator.");
+    }
+    if (!eventConfig || !eventConfig.name) {
+      throw new Error("Invalid eventConfig provided.");
+    }
+    const uniqueKey = Symbol(eventConfig.name);
+    Object.defineProperty(target, propertyKey, {
+      get() {
+        const emittersMap = eventEmitters.get(this) || new Map;
+        if (!emittersMap.has(uniqueKey)) {
+          emittersMap.set(uniqueKey, new EventEmitter(this, eventConfig));
+          eventEmitters.set(this, emittersMap);
+        }
+        return emittersMap.get(uniqueKey);
+      }
+    });
+  };
+}
+var eventEmitters = new WeakMap;
+
+// src/decorators/on-event.ts
+function onEvent(eventConfig) {
+  return (proto, _, descriptor) => {
+    const originalConnectedCallback = proto.connectedCallback;
+    const originalDisconnectedCallback = proto.disconnectedCallback;
+    if ("window" in eventConfig) {
+      proto.connectedCallback = function() {
+        window.addEventListener(eventConfig.type, descriptor.value.bind(this), eventConfig.options);
+        originalConnectedCallback.call(this);
+      };
+      proto.disconnectedCallback = function() {
+        window.removeEventListener(eventConfig.type, descriptor.value.bind(this), eventConfig.options);
+        originalDisconnectedCallback.call(this);
+      };
+      return descriptor;
+    }
+    if ("document" in eventConfig) {
+      proto.connectedCallback = function() {
+        document.addEventListener(eventConfig.type, descriptor.value.bind(this), eventConfig.options);
+        originalConnectedCallback.call(this);
+      };
+      proto.disconnectedCallback = function() {
+        document.removeEventListener(eventConfig.type, descriptor.value.bind(this), eventConfig.options);
+        originalDisconnectedCallback.call(this);
+      };
+      return descriptor;
+    }
+    const selector = "selector" in eventConfig ? eventConfig.selector : `[data-ref="${eventConfig.ref}"]`;
+    const originalMethod = descriptor.value;
+    const subscriptionId = `${eventConfig.type}-${selector}`;
+    proto.connectedCallback = function() {
+      this.subscribeEvent({
+        id: subscriptionId,
+        selector,
+        type: eventConfig.type,
+        listener: originalMethod.bind(this),
+        options: eventConfig?.options ?? undefined
+      });
+      originalConnectedCallback.call(this);
+    };
+    return descriptor;
+  };
+}
+
+// src/decorators/on-updated.ts
+function onUpdated(keyOrKeys) {
+  return (proto, methodName) => {
+    if (!("updatesRegistry" in proto)) {
+      Object.defineProperty(proto, "updatesRegistry", {
+        value: new Map,
+        configurable: true
+      });
+    }
+    const updatesRegistry = proto.updatesRegistry;
+    if (Array.isArray(keyOrKeys)) {
+      for (const key of keyOrKeys) {
+        if (!updatesRegistry.has(key)) {
+          updatesRegistry.set(key, new Set);
+        }
+        updatesRegistry.get(key)?.add(methodName);
+      }
+    } else if (typeof keyOrKeys === "string") {
+      if (!updatesRegistry.has(keyOrKeys)) {
+        updatesRegistry.set(keyOrKeys, new Set);
+      }
+      updatesRegistry.get(keyOrKeys)?.add(methodName);
+    }
+  };
+}
+
+// src/decorators/query.ts
+function query({
+  cache: shouldBeCached = true,
+  ...options
+}) {
+  const cache = new WeakMap;
+  return (proto, propertyKey) => {
+    const doQuery = function() {
+      if (shouldBeCached) {
+        const cachedResult = cache.get(this);
+        if (cachedResult !== undefined) {
+          return cachedResult;
+        }
+      }
+      const selector = "selector" in options ? options.selector : `[data-ref="${options.ref}"]`;
+      const queryResult = options.all ? this.querySelectorAll(selector) : this.querySelector(selector);
+      if (shouldBeCached) {
+        cache.set(this, queryResult);
+      }
+      return queryResult;
+    };
+    const originalConnectedCallback = proto.connectedCallback;
+    proto.connectedCallback = function() {
+      Object.defineProperty(this, propertyKey, {
+        get: doQuery,
+        enumerable: true,
+        configurable: true
+      });
+      originalConnectedCallback.call(this);
+    };
+  };
+}
+
+// src/utils/attribute-utils.ts
+function parseAttributeTypeConstant(constant) {
+  switch (constant) {
+    case Array:
+      return "array";
+    case Boolean:
+      return "boolean";
+    case Number:
+      return "number";
+    case Object:
+      return "object";
+    case String:
+      return "string";
+  }
+}
+function parseAttributeTypeDefault(defaultValue) {
+  switch (typeof defaultValue) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+  }
+  if (Array.isArray(defaultValue))
+    return "array";
+  if (Object.prototype.toString.call(defaultValue) === "[object Object]")
+    return "object";
+}
+function defaultValueForType(type) {
+  switch (type) {
+    case Number:
+      return 0;
+    case String:
+      return "";
+    case Boolean:
+      return false;
+    default:
+      return null;
+  }
+}
+function parseJSON(value) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new TypeError("Invalid JSON string");
+  }
+}
+function writeJSON(value) {
+  return JSON.stringify(value);
+}
+function writeString(value) {
+  return `${value}`;
+}
+function readAttributeValue(value, type) {
+  const readerType = parseAttributeTypeConstant(type);
+  if (!readerType)
+    throw new TypeError(`[radiant-element] Unknown type "${type}"`);
+  return readers[readerType](value);
+}
+function writeAttributeValue(value, type) {
+  const writerType = parseAttributeTypeConstant(type);
+  if (!writerType)
+    throw new TypeError(`[radiant-element] Unknown type "${type}"`);
+  return (writers[writerType] || writers.default)(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isObject(value) {
+  return typeof value === "object" && !Array.isArray(value) && value !== null;
+}
+function isValueOfType(type, defaultValue) {
+  switch (type) {
+    case Boolean:
+      return isBoolean(defaultValue);
+    case Number:
+      return isNumber(defaultValue);
+    case String:
+      return isString(defaultValue);
+    case Array:
+      return isArray(defaultValue);
+    case Object:
+      return isObject(defaultValue);
+    default:
+      return false;
+  }
+}
+var readers = {
+  array(value) {
+    const array = parseJSON(value);
+    if (!Array.isArray(array)) {
+      throw new TypeError(`Expected an array but got a value of type "${typeof array}"`);
+    }
+    return array;
+  },
+  boolean(value) {
+    return !(value === "0" || String(value).toLowerCase() === "false");
+  },
+  number(value) {
+    const number = Number(value.replace(/_/g, ""));
+    return number;
+  },
+  object(value) {
+    const object = JSON.parse(value);
+    if (object === null || typeof object !== "object" || Array.isArray(object)) {
+      throw new TypeError(`expected value of type "object" but instead got value "${value}" of type "${parseAttributeTypeDefault(object)}"`);
+    }
+    return object;
+  },
+  string(value) {
+    return value;
+  }
+};
+var writers = {
+  default: writeString,
+  array: writeJSON,
+  object: writeJSON
+};
+
+// src/decorators/reactive-prop.ts
+function reactiveProp({ type, attribute, reflect, defaultValue }) {
+  if (defaultValue !== undefined && !isValueOfType(type, defaultValue)) {
+    throw new Error(`defaultValue does not match the expected type for ${type.name}`);
+  }
+  return (target, propertyName) => {
+    const originalValues = new WeakMap;
+    const attributeKey = attribute ?? propertyName;
+    if (propertyName in target) {
+      throw new Error(`Property "${propertyName}" already exists on ${target.constructor.name}`);
+    }
+    const propertyMapping = {
+      type,
+      propertyName,
+      attributeKey,
+      converter: {
+        fromAttribute: (value) => readAttributeValue(value, type),
+        toAttribute: (value) => writeAttributeValue(value, type)
+      }
+    };
+    addPropertyToMappings(target, propertyMapping);
+    Object.defineProperty(target, propertyName, {
+      get: function() {
+        if (!originalValues.has(this)) {
+          const initialValue = getInitialValue(this, type, attributeKey, defaultValue);
+          originalValues.set(this, initialValue);
+        }
+        return originalValues.get(this);
+      },
+      set: function(newValue) {
+        const oldValue = originalValues.get(this);
+        if (oldValue === newValue)
+          return;
+        originalValues.set(this, newValue);
+        if (reflect) {
+          const attributeValue = propertyMapping.converter.toAttribute(newValue);
+          this.setAttribute(attributeKey, attributeValue);
+        }
+        this.updated(propertyName, oldValue, newValue);
+      },
+      enumerable: true,
+      configurable: true
+    });
+    const originalConnectedCallback = target.connectedCallback;
+    target.connectedCallback = function() {
+      originalConnectedCallback.call(this);
+      this.updated(propertyName, null, defaultValue);
+    };
+    addObservedAttribute(target, attributeKey);
+  };
+}
+function addObservedAttribute(target, attribute) {
+  const ctor = target.constructor;
+  const existingObservedAttributes = ctor.observedAttributes || [];
+  if (!existingObservedAttributes.includes(attribute)) {
+    const newObservedAttributes = [...existingObservedAttributes, attribute];
+    Object.defineProperty(ctor, "observedAttributes", {
+      get() {
+        return newObservedAttributes;
+      },
+      configurable: true
+    });
+  }
+}
+var getInitialValue = (target, type, attributeKey, defaultValue) => {
+  if (type === Boolean) {
+    const hasAttribute = target.hasAttribute(attributeKey);
+    return hasAttribute || defaultValue;
+  }
+  const attributeValue = target.getAttribute(attributeKey);
+  return attributeValue !== null ? readAttributeValue(attributeValue, type) : defaultValue || defaultValueForType(type);
+};
+var addPropertyToMappings = (target, propertyMapping) => {
+  if (!("propertyConfigMap" in target)) {
+    Object.defineProperty(target, "propertyConfigMap", {
+      value: new Map,
+      configurable: true
+    });
+  }
+  target.propertyConfigMap.set(propertyMapping.propertyName, propertyMapping);
+};
+
+// src/decorators/reactive-field.ts
+function reactiveField(proto, propertyKey) {
+  const originalValues = new WeakMap;
+  const isDefined = new WeakSet;
+  Object.defineProperty(proto, propertyKey, {
+    get: function() {
+      return originalValues.get(this);
+    },
+    set: function(newValue) {
+      if (isDefined.has(this)) {
+        const oldValue = originalValues.get(this);
+        if (oldValue !== newValue) {
+          originalValues.set(this, newValue);
+          this.updated(propertyKey, oldValue, newValue);
+        }
+      } else {
+        originalValues.set(this, newValue);
+        isDefined.add(this);
+      }
+    }
+  });
+}
+export {
+  reactiveProp,
+  reactiveField,
+  query,
+  onUpdated,
+  onEvent,
+  event,
+  customElement
+};
+
+//# debugId=4CC8B2D8AD40ADE664756E2164756E21