@bquery/bquery 1.1.2 → 1.3.0

package/dist/batch-4LAvfLE7.js

@@ -0,0 +1,13 @@
+import { e as t, b } from "./core-COenAZjD.js";
+const e = (a) => {
+  b();
+  try {
+    a();
+  } finally {
+    t();
+  }
+};
+export {
+  e as b
+};
+//# sourceMappingURL=batch-4LAvfLE7.js.map

package/dist/batch-4LAvfLE7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-4LAvfLE7.js","sources":["../src/reactive/batch.ts"],"sourcesContent":["/**\n * Batched reactive updates.\n */\n\nimport { beginBatch, endBatch } from './internals';\n\n/**\n * Batches multiple signal updates into a single notification cycle.\n *\n * Updates made inside the batch function are deferred until the batch\n * completes, preventing intermediate re-renders and improving performance.\n *\n * @param fn - Function containing multiple signal updates\n */\nexport const batch = (fn: () => void): void => {\n  beginBatch();\n  try {\n    fn();\n  } finally {\n    endBatch();\n  }\n};\n"],"names":["batch","fn","beginBatch","endBatch"],"mappings":";AAcO,MAAMA,IAAQ,CAACC,MAAyB;AAC7C,EAAAC,EAAA;AACA,MAAI;AACF,IAAAD,EAAA;AAAA,EACF,UAAA;AACE,IAAAE,EAAA;AAAA,EACF;AACF;"}

package/dist/component/component.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Web Component factory and registry.
+ *
+ * @module bquery/component
+ */
+import type { ComponentDefinition } from './types';
+/**
+ * Creates a custom element class for a component definition.
+ *
+ * This is useful when you want to extend or register the class manually
+ * (e.g. with different tag names in tests or custom registries).
+ *
+ * @template TProps - Type of the component's props
+ * @param tagName - The custom element tag name (used for diagnostics)
+ * @param definition - The component configuration
+ */
+export declare const defineComponent: <TProps extends Record<string, unknown>>(tagName: string, definition: ComponentDefinition<TProps>) => typeof HTMLElement;
+/**
+ * Defines and registers a custom Web Component.
+ *
+ * This function creates a new custom element with the given tag name
+ * and configuration. The component uses Shadow DOM for encapsulation
+ * and automatically re-renders when observed attributes change.
+ *
+ * @template TProps - Type of the component's props
+ * @param tagName - The custom element tag name (must contain a hyphen)
+ * @param definition - The component configuration
+ *
+ * @example
+ * ```ts
+ * component('counter-button', {
+ *   props: {
+ *     start: { type: Number, default: 0 },
+ *   },
+ *   state: { count: 0 },
+ *   styles: `
+ *     button { padding: 0.5rem 1rem; }
+ *   `,
+ *   connected() {
+ *     // Use event delegation on shadow root so handler survives re-renders
+ *     const handleClick = (event: Event) => {
+ *       const target = event.target as HTMLElement | null;
+ *       if (target?.matches('button')) {
+ *         this.setState('count', (this.getState('count') as number) + 1);
+ *       }
+ *     };
+ *     this.shadowRoot?.addEventListener('click', handleClick);
+ *     // Store handler for cleanup
+ *     (this as any)._handleClick = handleClick;
+ *   },
+ *   disconnected() {
+ *     // Clean up event listener to prevent memory leaks
+ *     const handleClick = (this as any)._handleClick;
+ *     if (handleClick) {
+ *       this.shadowRoot?.removeEventListener('click', handleClick);
+ *     }
+ *   },
+ *   render({ props, state }) {
+ *     return html`
+ *       <button>
+ *         Count: ${state.count}
+ *       </button>
+ *     `;
+ *   },
+ * });
+ * ```
+ */
+export declare const component: <TProps extends Record<string, unknown>>(tagName: string, definition: ComponentDefinition<TProps>) => void;
+//# sourceMappingURL=component.d.ts.map

package/dist/component/component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../../src/component/component.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAkB,MAAM,SAAS,CAAC;AAEnE;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAAI,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpE,SAAS,MAAM,EACf,YAAY,mBAAmB,CAAC,MAAM,CAAC,KACtC,OAAO,WA4MT,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9D,SAAS,MAAM,EACf,YAAY,mBAAmB,CAAC,MAAM,CAAC,KACtC,IAMF,CAAC"}

package/dist/component/html.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Tagged template literal for creating HTML strings.
+ *
+ * This function handles interpolation of values into HTML templates,
+ * converting null/undefined to empty strings.
+ *
+ * @param strings - Template literal string parts
+ * @param values - Interpolated values
+ * @returns Combined HTML string
+ *
+ * @example
+ * ```ts
+ * const name = 'World';
+ * const greeting = html`<h1>Hello, ${name}!</h1>`;
+ * // Result: '<h1>Hello, World!</h1>'
+ * ```
+ */
+export declare const html: (strings: TemplateStringsArray, ...values: unknown[]) => string;
+/**
+ * Escapes HTML entities in interpolated values for XSS prevention.
+ * Use this when you need to safely embed user content in templates.
+ *
+ * @param strings - Template literal string parts
+ * @param values - Interpolated values to escape
+ * @returns Combined HTML string with escaped values
+ *
+ * @example
+ * ```ts
+ * const userInput = '<script>alert("xss")</script>';
+ * const safe = safeHtml`<div>${userInput}</div>`;
+ * // Result: '<div>&lt;script&gt;alert("xss")&lt;/script&gt;</div>'
+ * ```
+ */
+export declare const safeHtml: (strings: TemplateStringsArray, ...values: unknown[]) => string;
+//# sourceMappingURL=html.d.ts.map

package/dist/component/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../../src/component/html.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,IAAI,GAAI,SAAS,oBAAoB,EAAE,GAAG,QAAQ,OAAO,EAAE,KAAG,MAE1E,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,QAAQ,GAAI,SAAS,oBAAoB,EAAE,GAAG,QAAQ,OAAO,EAAE,KAAG,MAgB9E,CAAC"}

package/dist/component/index.d.ts

@@ -34,130 +34,7 @@
  * });
  * ```
  */
-/**
- * Defines a single prop's type and configuration.
- *
- * @template T - The TypeScript type of the prop value
- *
- * @example
- * ```ts
- * const myProp: PropDefinition<number> = {
- *   type: Number,
- *   required: false,
- *   default: 0,
- * };
- * ```
- */
-export type PropDefinition<T = unknown> = {
-    /** Constructor or converter function for the prop type */
-    type: StringConstructor | NumberConstructor | BooleanConstructor | ObjectConstructor | ArrayConstructor | {
-        new (value: unknown): T;
-    } | ((value: unknown) => T);
-    /** Whether the prop must be provided */
-    required?: boolean;
-    /** Default value when prop is not provided */
-    default?: T;
-    /** Optional validator function to validate prop values */
-    validator?: (value: T) => boolean;
-};
-/**
- * Complete component definition including props, state, styles, and lifecycle.
- *
- * @template TProps - Type of the component's props
- */
-export type ComponentDefinition<TProps extends Record<string, unknown> = Record<string, unknown>> = {
-    /** Prop definitions with types and defaults */
-    props?: Record<keyof TProps, PropDefinition>;
-    /** Initial internal state */
-    state?: Record<string, unknown>;
-    /** CSS styles scoped to the component's shadow DOM */
-    styles?: string;
-    /** Lifecycle hook called before the component mounts (before first render) */
-    beforeMount?: () => void;
-    /** Lifecycle hook called when component is added to DOM */
-    connected?: () => void;
-    /** Lifecycle hook called when component is removed from DOM */
-    disconnected?: () => void;
-    /** Lifecycle hook called before an update render; return false to prevent */
-    beforeUpdate?: (props: TProps) => boolean | void;
-    /** Lifecycle hook called after reactive updates trigger a render */
-    updated?: () => void;
-    /** Error handler for errors during rendering or lifecycle */
-    onError?: (error: Error) => void;
-    /** Render function returning HTML string */
-    render: (context: {
-        props: TProps;
-        state: Record<string, unknown>;
-        emit: (event: string, detail?: unknown) => void;
-    }) => string;
-};
-/**
- * Tagged template literal for creating HTML strings.
- *
- * This function handles interpolation of values into HTML templates,
- * converting null/undefined to empty strings.
- *
- * @param strings - Template literal string parts
- * @param values - Interpolated values
- * @returns Combined HTML string
- *
- * @example
- * ```ts
- * const name = 'World';
- * const greeting = html`<h1>Hello, ${name}!</h1>`;
- * // Result: '<h1>Hello, World!</h1>'
- * ```
- */
-export declare const html: (strings: TemplateStringsArray, ...values: unknown[]) => string;
-/**
- * Escapes HTML entities in interpolated values for XSS prevention.
- * Use this when you need to safely embed user content in templates.
- *
- * @param strings - Template literal string parts
- * @param values - Interpolated values to escape
- * @returns Combined HTML string with escaped values
- *
- * @example
- * ```ts
- * const userInput = '<script>alert("xss")</script>';
- * const safe = safeHtml`<div>${userInput}</div>`;
- * // Result: '<div>&lt;script&gt;alert("xss")&lt;/script&gt;</div>'
- * ```
- */
-export declare const safeHtml: (strings: TemplateStringsArray, ...values: unknown[]) => string;
-/**
- * Defines and registers a custom Web Component.
- *
- * This function creates a new custom element with the given tag name
- * and configuration. The component uses Shadow DOM for encapsulation
- * and automatically re-renders when observed attributes change.
- *
- * @template TProps - Type of the component's props
- * @param tagName - The custom element tag name (must contain a hyphen)
- * @param definition - The component configuration
- *
- * @example
- * ```ts
- * component('counter-button', {
- *   props: {
- *     start: { type: Number, default: 0 },
- *   },
- *   state: { count: 0 },
- *   styles: `
- *     button { padding: 0.5rem 1rem; }
- *   `,
- *   connected() {
- *     console.log('Counter mounted');
- *   },
- *   render({ props, state, emit }) {
- *     return html`
- *       <button onclick="this.getRootNode().host.increment()">
- *         Count: ${state.count}
- *       </button>
- *     `;
- *   },
- * });
- * ```
- */
-export declare const component: <TProps extends Record<string, unknown>>(tagName: string, definition: ComponentDefinition<TProps>) => void;
+export { component, defineComponent } from './component';
+export { html, safeHtml } from './html';
+export type { ComponentDefinition, ComponentRenderContext, PropDefinition } from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/component/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/component/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,OAAO,IAAI;IACxC,0DAA0D;IAC1D,IAAI,EACA,iBAAiB,GACjB,iBAAiB,GACjB,kBAAkB,GAClB,iBAAiB,GACjB,gBAAgB,GAChB;QAAE,KAAK,KAAK,EAAE,OAAO,GAAG,CAAC,CAAA;KAAE,GAC3B,CAAC,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,CAAC,CAAC;IAC5B,wCAAwC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,OAAO,CAAC,EAAE,CAAC,CAAC;IACZ,0DAA0D;IAC1D,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;CACnC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAC9F;IACE,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,MAAM,EAAE,cAAc,CAAC,CAAC;IAC7C,6BAA6B;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,sDAAsD;IACtD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,+DAA+D;IAC/D,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,6EAA6E;IAC7E,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,CAAC;IACjD,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,4CAA4C;IAC5C,MAAM,EAAE,CAAC,OAAO,EAAE;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC/B,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;KACjD,KAAK,MAAM,CAAC;CACd,CAAC;AAsDJ;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,IAAI,GAAI,SAAS,oBAAoB,EAAE,GAAG,QAAQ,OAAO,EAAE,KAAG,MAE1E,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,QAAQ,GAAI,SAAS,oBAAoB,EAAE,GAAG,QAAQ,OAAO,EAAE,KAAG,MAgB9E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9D,SAAS,MAAM,EACf,YAAY,mBAAmB,CAAC,MAAM,CAAC,KACtC,IAwKF,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/component/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACxC,YAAY,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC"}

package/dist/component/props.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Prop coercion utilities.
+ *
+ * @module bquery/component
+ */
+import type { PropDefinition } from './types';
+/**
+ * Coerces a string attribute value into a typed prop value.
+ * Supports String, Number, Boolean, Object, Array, and custom converters.
+ *
+ * @internal
+ * @template T - The target type
+ * @param rawValue - The raw string value from the attribute
+ * @param config - The prop definition with type information
+ * @returns The coerced value of type T
+ */
+export declare const coercePropValue: <T>(rawValue: string, config: PropDefinition<T>) => T;
+//# sourceMappingURL=props.d.ts.map

package/dist/component/props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../../src/component/props.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,UAAU,MAAM,EAAE,QAAQ,cAAc,CAAC,CAAC,CAAC,KAAG,CAiGhF,CAAC"}

package/dist/component/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Component types and render context definitions.
+ *
+ * @module bquery/component
+ */
+/**
+ * Defines a single prop's type and configuration.
+ *
+ * @template T - The TypeScript type of the prop value
+ *
+ * @example
+ * ```ts
+ * const myProp: PropDefinition<number> = {
+ *   type: Number,
+ *   required: false,
+ *   default: 0,
+ * };
+ * ```
+ */
+export type PropDefinition<T = unknown> = {
+    /** Constructor or converter function for the prop type */
+    type: StringConstructor | NumberConstructor | BooleanConstructor | ObjectConstructor | ArrayConstructor | {
+        new (value: unknown): T;
+    } | ((value: unknown) => T);
+    /** Whether the prop must be provided */
+    required?: boolean;
+    /** Default value when prop is not provided */
+    default?: T;
+    /** Optional validator function to validate prop values */
+    validator?: (value: T) => boolean;
+    /**
+     * Explicitly control whether to invoke `type` with `new` (constructor) or as a plain function.
+     * - `true`: Always use `new type(value)` (for class constructors, Date, etc.)
+     * - `false`: Always call `type(value)` (for converter functions)
+     * - `undefined` (default): Auto-detect based on heuristics with fallback
+     */
+    construct?: boolean;
+};
+/**
+ * Render context passed into a component render function.
+ */
+export type ComponentRenderContext<TProps extends Record<string, unknown>> = {
+    /** Typed props object populated from attributes */
+    props: TProps;
+    /** Internal mutable state object */
+    state: Record<string, unknown>;
+    /** Emit a custom event from the component */
+    emit: (event: string, detail?: unknown) => void;
+};
+/**
+ * Complete component definition including props, state, styles, and lifecycle.
+ *
+ * @template TProps - Type of the component's props
+ */
+export type ComponentDefinition<TProps extends Record<string, unknown> = Record<string, unknown>> = {
+    /** Prop definitions with types and defaults */
+    props?: Record<keyof TProps, PropDefinition>;
+    /** Initial internal state */
+    state?: Record<string, unknown>;
+    /** CSS styles scoped to the component's shadow DOM */
+    styles?: string;
+    /** Lifecycle hook called before the component mounts (before first render) */
+    beforeMount?: () => void;
+    /** Lifecycle hook called when component is added to DOM */
+    connected?: () => void;
+    /** Lifecycle hook called when component is removed from DOM */
+    disconnected?: () => void;
+    /** Lifecycle hook called before an update render; return false to prevent */
+    beforeUpdate?: (props: TProps) => boolean | void;
+    /** Lifecycle hook called after reactive updates trigger a render */
+    updated?: () => void;
+    /** Error handler for errors during rendering or lifecycle */
+    onError?: (error: Error) => void;
+    /** Render function returning HTML string */
+    render: (context: ComponentRenderContext<TProps>) => string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/component/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/component/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,OAAO,IAAI;IACxC,0DAA0D;IAC1D,IAAI,EACA,iBAAiB,GACjB,iBAAiB,GACjB,kBAAkB,GAClB,iBAAiB,GACjB,gBAAgB,GAChB;QAAE,KAAK,KAAK,EAAE,OAAO,GAAG,CAAC,CAAA;KAAE,GAC3B,CAAC,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,CAAC,CAAC;IAC5B,wCAAwC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,OAAO,CAAC,EAAE,CAAC,CAAC;IACZ,0DAA0D;IAC1D,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;IAClC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,sBAAsB,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI;IAC3E,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,6CAA6C;IAC7C,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;CACjD,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAC9F;IACE,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,MAAM,EAAE,cAAc,CAAC,CAAC;IAC7C,6BAA6B;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,sDAAsD;IACtD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,+DAA+D;IAC/D,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,6EAA6E;IAC7E,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,CAAC;IACjD,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,4CAA4C;IAC5C,MAAM,EAAE,CAAC,OAAO,EAAE,sBAAsB,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC;CAC7D,CAAC"}

package/dist/component.es.mjs

@@ -1,43 +1,52 @@
-const u = (e, r) => {
-  const { type: o } = r;
-  if (o === String) return e;
-  if (o === Number) {
-    const s = Number(e);
-    return Number.isNaN(s) ? e : s;
+import { s as h } from "./sanitize-1FBEPAFH.js";
+const p = (e, r) => {
+  const { type: s } = r;
+  if (s === String) return e;
+  if (s === Number)
+    return Number(e);
+  if (s === Boolean) {
+    const c = e.trim().toLowerCase();
+    return c === "" || c === "true" || c === "1" ? !0 : c === "false" || c === "0" ? !1 : !!e;
   }
-  if (o === Boolean) {
-    const s = e.trim().toLowerCase();
-    return s === "" || s === "true" || s === "1" ? !0 : s === "false" || s === "0" ? !1 : !!e;
-  }
-  if (o === Object || o === Array)
+  if (s === Object || s === Array)
     try {
       return JSON.parse(e);
     } catch {
       return e;
     }
-  if (typeof o == "function") {
-    const s = o, t = o;
+  if (typeof s == "function") {
+    const c = s, t = s;
+    if (r.construct === !0)
+      return Reflect.construct(t, [e]);
+    if (r.construct === !1)
+      return c(e);
+    const o = s.prototype !== void 0 && s.prototype !== null, u = (o ? Object.getOwnPropertyNames(s.prototype) : []).length > 1, n = o && s.prototype.constructor !== s, l = /^class\s/.test(Function.prototype.toString.call(s));
+    if (u || n || l)
+      try {
+        return Reflect.construct(t, [e]);
+      } catch {
+        return c(e);
+      }
     try {
-      return s(e);
-    } catch {
-      return new t(e);
+      const a = c(e);
+      if (a === void 0 && o)
+        try {
+          return Reflect.construct(t, [e]);
+        } catch {
+          return a;
+        }
+      return a;
+    } catch (a) {
+      if (a instanceof TypeError && /cannot be invoked without 'new'|is not a function/i.test(a.message))
+        return Reflect.construct(t, [e]);
+      throw a;
     }
   }
   return e;
-}, p = (e, ...r) => e.reduce((o, s, t) => `${o}${s}${r[t] ?? ""}`, ""), i = (e, ...r) => {
-  const o = {
-    "&": "&",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#x27;",
-    "`": "&#x60;"
-  }, s = (t) => String(t ?? "").replace(/[&<>"'`]/g, (n) => o[n]);
-  return e.reduce((t, c, n) => `${t}${c}${s(r[n])}`, "");
 }, d = (e, r) => {
-  class o extends HTMLElement {
+  class s extends HTMLElement {
     constructor() {
-      super(), this.state = { ...r.state ?? {} }, this.props = {}, this.attachShadow({ mode: "open" }), this.syncProps();
+      super(), this.state = { ...r.state ?? {} }, this.props = {}, this.missingRequiredProps = /* @__PURE__ */ new Set(), this.hasMounted = !1, this.attachShadow({ mode: "open" }), this.syncProps();
     }
     /**
      * Returns the list of attributes to observe for changes.
@@ -50,11 +59,21 @@ const u = (e, r) => {
      */
     connectedCallback() {
       try {
-        r.beforeMount?.call(this), r.connected?.call(this), this.render();
+        if (this.missingRequiredProps.size > 0)
+          return;
+        this.mount();
       } catch (t) {
         this.handleError(t);
       }
     }
+    /**
+     * Performs the initial mount of the component.
+     * Called when the element is connected and all required props are present.
+     * @internal
+     */
+    mount() {
+      this.hasMounted || (r.beforeMount?.call(this), r.connected?.call(this), this.render(), this.hasMounted = !0);
+    }
     /**
      * Called when the element is removed from the DOM.
      */
@@ -68,11 +87,11 @@ const u = (e, r) => {
     /**
      * Called when an observed attribute changes.
      */
-    attributeChangedCallback() {
+    attributeChangedCallback(t, o, i) {
       try {
-        this.syncProps(), this.render(!0);
-      } catch (t) {
-        this.handleError(t);
+        this.syncProps(), this.hasMounted ? this.render(!0) : this.isConnected && this.missingRequiredProps.size === 0 && this.mount();
+      } catch (u) {
+        this.handleError(u);
       }
     }
     /**
@@ -88,8 +107,8 @@ const u = (e, r) => {
      * @param key - The state property key
      * @param value - The new value
      */
-    setState(t, c) {
-      this.state[t] = c, this.render(!0);
+    setState(t, o) {
+      this.state[t] = o, this.render(!0);
     }
     /**
      * Gets a state property value.
@@ -106,20 +125,14 @@ const u = (e, r) => {
      */
     syncProps() {
       const t = r.props ?? {};
-      for (const [c, n] of Object.entries(t)) {
-        const l = this.getAttribute(c);
-        let a;
-        if (l == null) {
-          if (n.required && n.default === void 0)
-            throw new Error(`bQuery component: missing required prop "${c}"`);
-          a = n.default ?? void 0;
-        } else
-          a = u(l, n);
-        if (n.validator && a !== void 0 && !n.validator(a))
+      for (const [o, i] of Object.entries(t)) {
+        const u = this.getAttribute(o);
+        let n;
+        if (u == null ? i.required && i.default === void 0 ? (this.missingRequiredProps.add(o), n = void 0) : n = i.default ?? void 0 : (this.missingRequiredProps.has(o) && this.missingRequiredProps.delete(o), n = p(u, i)), i.validator && n !== void 0 && !i.validator(n))
           throw new Error(
-            `bQuery component: validation failed for prop "${c}" with value ${JSON.stringify(a)}`
+            `bQuery component: validation failed for prop "${o}" with value ${JSON.stringify(n)}`
           );
-        this.props[c] = a;
+        this.props[o] = n;
       }
     }
     /**
@@ -130,26 +143,44 @@ const u = (e, r) => {
       try {
         if (t && r.beforeUpdate && r.beforeUpdate.call(this, this.props) === !1)
           return;
-        const c = (a, h) => {
-          this.dispatchEvent(new CustomEvent(a, { detail: h, bubbles: !0, composed: !0 }));
+        const o = (n, l) => {
+          this.dispatchEvent(new CustomEvent(n, { detail: l, bubbles: !0, composed: !0 }));
         };
         if (!this.shadowRoot) return;
-        const n = r.render({
+        const i = r.render({
           props: this.props,
           state: this.state,
-          emit: c
-        }), l = r.styles ? `<style>${r.styles}</style>` : "";
-        this.shadowRoot.innerHTML = `${l}${n}`, t && r.updated?.call(this);
-      } catch (c) {
-        this.handleError(c);
+          emit: o
+        }), u = h(i);
+        if (this.shadowRoot.innerHTML = u, r.styles) {
+          const n = document.createElement("style");
+          n.textContent = r.styles, this.shadowRoot.prepend(n);
+        }
+        t && r.updated?.call(this);
+      } catch (o) {
+        this.handleError(o);
       }
     }
   }
-  customElements.get(e) || customElements.define(e, o);
+  return s;
+}, b = (e, r) => {
+  const s = d(e, r);
+  customElements.get(e) || customElements.define(e, s);
+}, E = (e, ...r) => e.reduce((s, c, t) => `${s}${c}${r[t] ?? ""}`, ""), g = (e, ...r) => {
+  const s = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#x27;",
+    "`": "&#x60;"
+  }, c = (t) => String(t ?? "").replace(/[&<>"'`]/g, (i) => s[i]);
+  return e.reduce((t, o, i) => `${t}${o}${c(r[i])}`, "");
 };
 export {
-  d as component,
-  p as html,
-  i as safeHtml
+  b as component,
+  d as defineComponent,
+  E as html,
+  g as safeHtml
 };
 //# sourceMappingURL=component.es.mjs.map