elements-kit 0.0.7 → 0.0.9

package/dist/slot-Cydy7-0L.mjs

@@ -0,0 +1,180 @@
+import "./polyfill-B1lNNcum.mjs";
+//#region src/lib.ts
+var UnsupportedChildError = class extends Error {
+	constructor(value) {
+		super(`Unsupported child type: ${typeof value}`);
+		this.name = "UnsupportedChildError";
+	}
+};
+function resolveNode(c) {
+	if (c instanceof Node) return c;
+	if (c === null || c === void 0 || typeof c === "boolean") return document.createComment("");
+	if (typeof c === "string" || typeof c === "number" || typeof c === "bigint" || typeof c === "symbol" || c instanceof Date || c instanceof RegExp) return document.createTextNode(String(c));
+	throw new UnsupportedChildError(c);
+}
+//#endregion
+//#region src/slot.ts
+/**
+* A lightweight slot that reserves a region in the DOM using comment markers.
+* Content between the markers can be replaced dynamically without wrapper elements.
+*/
+var Slot = class Slot {
+	start = document.createComment("{");
+	end = document.createComment("}");
+	#pending;
+	/**
+	* Render the slot as a DocumentFragment.
+	* If not yet mounted, inserts the comment markers and optional default content.
+	* If already mounted, extracts and returns the current content WITHOUT disposing
+	* it — the caller takes ownership of the returned nodes and is responsible for
+	* their disposal.
+	*/
+	slot(defaultContent) {
+		const fragment = document.createDocumentFragment();
+		if (this.isMounted()) {
+			const range = document.createRange();
+			range.setStartAfter(this.start);
+			range.setEndBefore(this.end);
+			fragment.appendChild(range.extractContents());
+			return fragment;
+		}
+		fragment.appendChild(this.start);
+		fragment.appendChild(this.end);
+		const initialContent = this.#pending ?? resolveNode(defaultContent);
+		if (initialContent) fragment.insertBefore(initialContent, this.end);
+		this.#pending = void 0;
+		return fragment;
+	}
+	/** Dispose reactive children and remove all content between the markers. */
+	clear() {
+		let node = this.start.nextSibling;
+		while (node && node !== this.end) {
+			const next = node.nextSibling;
+			if (node instanceof Element) node[Symbol.dispose]?.();
+			node = next;
+		}
+		const range = document.createRange();
+		range.setStartAfter(this.start);
+		range.setEndBefore(this.end);
+		range.deleteContents();
+	}
+	/**
+	* Replace the slot's content with the given element.
+	* No-op if the slot is not mounted or the content is identical.
+	*/
+	set(element) {
+		const parent = this.parent();
+		if (!parent) {
+			this.#pending = element;
+			return;
+		}
+		if (this.isSame(element)) return;
+		this.clear();
+		parent.insertBefore(element, this.end);
+		this.#pending = void 0;
+	}
+	/**
+	* Extract and return the current slot content as a DocumentFragment.
+	* Returns `null` if the slot is not mounted.
+	* Content is NOT disposed — the caller takes ownership and is responsible
+	* for disposal.
+	*/
+	get() {
+		if (!this.isMounted()) return null;
+		const range = document.createRange();
+		range.setStartAfter(this.start);
+		range.setEndBefore(this.end);
+		return range.extractContents();
+	}
+	/** Returns the parent node if the slot is mounted, otherwise `null`. */
+	parent() {
+		return this.isMounted() ? this.start.parentNode : null;
+	}
+	/** Whether the slot's comment markers are attached to the DOM. */
+	isMounted() {
+		return this.start.parentNode === this.end.parentNode && !!this.start.parentNode;
+	}
+	isSame(element) {
+		return this.start.nextSibling === element && this.end === element.nextSibling;
+	}
+	/**
+	* Create a callable slot instance.
+	*
+	* The returned value is both a function and an object:
+	* - Call it to render the slot with optional default content.
+	* - Access `.set()`, `.parent()`, `.isMounted()` for slot management.
+	*
+	* @example
+	* ```ts
+	* const slot = createSlot();
+	* el.append(slot("default text"));  // mount with default
+	* slot.set(newElement);              // replace content
+	* ```
+	*/
+	static new() {
+		const instance = new Slot();
+		return new Proxy(instance.slot.bind(instance), {
+			apply(target, _thisArg, argArray) {
+				return target(...argArray);
+			},
+			get(_target, prop) {
+				const value = instance[prop];
+				return typeof value === "function" ? value.bind(instance) : value;
+			},
+			getPrototypeOf() {
+				return Slot.prototype;
+			}
+		});
+	}
+};
+/** A callable slot — invoke to render, or access `.set()` / `.isMounted()` / `.parent()` for management. */
+/**
+* Symbol key for attaching a `Slots` instance to a custom element instance.
+* This prevent collisions with Element properties and are not meant to be treated as JSX children.
+*/
+const $slots = Symbol("slots");
+const $map = Symbol("map");
+const $keys = Symbol("keys");
+const $has = Symbol("has");
+/**
+* A keyed collection of slot instances.
+* Slots are pre-created from the provided keys and lazily created on first access for unknown keys.
+*/
+var Slots = class Slots {
+	[$map] = /* @__PURE__ */ new Map();
+	constructor(keys = []) {
+		for (const key of keys) this[$map].set(key, Slot.new());
+	}
+	[Symbol.iterator]() {
+		return this[$map][Symbol.iterator]();
+	}
+	[Symbol.toStringTag]() {
+		return "Slots";
+	}
+	[Symbol.hasInstance](instance) {
+		return instance instanceof Slots;
+	}
+	[$has](key) {
+		return this[$map].has(key);
+	}
+	/** Check whether a slot with the given key exists. */
+	static has(slots, key) {
+		return slots[$has](key);
+	}
+	[$keys]() {
+		return this[$map].keys();
+	}
+	/** Iterate over all registered slot keys. */
+	static keys(slots) {
+		return slots[$keys]();
+	}
+	static new(keys) {
+		const instance = new Slots(keys);
+		return new Proxy(instance, { get(target, prop, receiver) {
+			if (typeof prop === "string" && target[$map].has(prop)) return target[$map].get(prop);
+			return Reflect.get(target, prop, receiver);
+		} });
+	}
+};
+//#endregion
+export { resolveNode as i, Slot as n, Slots as r, $slots as t };

package/dist/slot.d.mts

@@ -1,4 +1,4 @@
-import { o as ElementBuilder } from "./index-Ukqj0EcT.mjs";
+import { t as PrimitiveNodeType } from "./polyfill-AFIi9kAN.mjs";
 
 //#region src/slot.d.ts
 /**
@@ -6,13 +6,9 @@ import { o as ElementBuilder } from "./index-Ukqj0EcT.mjs";
  * Content between the markers can be replaced dynamically without wrapper elements.
  */
 declare class Slot {
+  #private;
   private readonly start;
   private readonly end;
-  /**
-   * Render the slot as a DocumentFragment.
-   * If not yet mounted, inserts the comment markers and optional default content.
-   * If already mounted, extracts and returns the current content.
-   */
   /**
    * Render the slot as a DocumentFragment.
    * If not yet mounted, inserts the comment markers and optional default content.
@@ -20,7 +16,7 @@ declare class Slot {
    * it — the caller takes ownership of the returned nodes and is responsible for
    * their disposal.
    */
-  slot(defaultContent?: string | Node | ElementBuilder): DocumentFragment;
+  slot(defaultContent?: PrimitiveNodeType): DocumentFragment;
   /** Dispose reactive children and remove all content between the markers. */
   clear(): void;
   /**
@@ -54,7 +50,7 @@ declare class Slot {
    * slot.set(newElement);              // replace content
    * ```
    */
-  static new(): Slot & ((defaultContent?: string | Node | ElementBuilder) => DocumentFragment);
+  static new(): Slot & ((defaultContent?: PrimitiveNodeType) => DocumentFragment);
 }
 type SlotInstance = ReturnType<typeof Slot.new>;
 /** A callable slot — invoke to render, or access `.set()` / `.isMounted()` / `.parent()` for management. */
@@ -71,9 +67,9 @@ declare const $has: unique symbol;
  * Slots are pre-created from the provided keys and lazily created on first access for unknown keys.
  */
 declare class Slots<K extends string> implements Iterable<[K, SlotInstance]> {
-  readonly [$map]: Map<K, Slot & ((defaultContent?: string | Node | ElementBuilder) => DocumentFragment)>;
+  readonly [$map]: Map<K, Slot & ((defaultContent?: PrimitiveNodeType) => DocumentFragment)>;
   private constructor();
-  [Symbol.iterator](): MapIterator<[K, Slot & ((defaultContent?: string | Node | ElementBuilder) => DocumentFragment)]>;
+  [Symbol.iterator](): MapIterator<[K, Slot & ((defaultContent?: PrimitiveNodeType) => DocumentFragment)]>;
   [Symbol.toStringTag](): string;
   [Symbol.hasInstance](instance: unknown): instance is Slots<any>;
   [$has](key: K): boolean;

package/dist/slot.mjs

@@ -1,166 +1,2 @@
-import "./polyfill-B1lNNcum.mjs";
-//#region src/slot.ts
-/**
-* A lightweight slot that reserves a region in the DOM using comment markers.
-* Content between the markers can be replaced dynamically without wrapper elements.
-*/
-var Slot = class Slot {
-	start = document.createComment("{");
-	end = document.createComment("}");
-	/**
-	* Render the slot as a DocumentFragment.
-	* If not yet mounted, inserts the comment markers and optional default content.
-	* If already mounted, extracts and returns the current content.
-	*/
-	/**
-	* Render the slot as a DocumentFragment.
-	* If not yet mounted, inserts the comment markers and optional default content.
-	* If already mounted, extracts and returns the current content WITHOUT disposing
-	* it — the caller takes ownership of the returned nodes and is responsible for
-	* their disposal.
-	*/
-	slot(defaultContent) {
-		const fragment = document.createDocumentFragment();
-		if (this.isMounted()) {
-			const range = document.createRange();
-			range.setStartAfter(this.start);
-			range.setEndBefore(this.end);
-			fragment.appendChild(range.extractContents());
-			return fragment;
-		}
-		fragment.appendChild(this.start);
-		fragment.appendChild(this.end);
-		if (defaultContent) {
-			const defaultNode = typeof defaultContent === "string" ? document.createTextNode(defaultContent) : defaultContent instanceof Node ? defaultContent : defaultContent.ref();
-			fragment.insertBefore(defaultNode, this.end);
-		}
-		return fragment;
-	}
-	/** Dispose reactive children and remove all content between the markers. */
-	clear() {
-		let node = this.start.nextSibling;
-		while (node && node !== this.end) {
-			const next = node.nextSibling;
-			if (node instanceof Element) node[Symbol.dispose]?.();
-			node = next;
-		}
-		const range = document.createRange();
-		range.setStartAfter(this.start);
-		range.setEndBefore(this.end);
-		range.deleteContents();
-	}
-	/**
-	* Replace the slot's content with the given element.
-	* No-op if the slot is not mounted or the content is identical.
-	*/
-	set(element) {
-		const parent = this.parent();
-		if (!parent) return;
-		if (this.isSame(element)) return;
-		this.clear();
-		parent.insertBefore(element, this.end);
-	}
-	/**
-	* Extract and return the current slot content as a DocumentFragment.
-	* Returns `null` if the slot is not mounted.
-	* Content is NOT disposed — the caller takes ownership and is responsible
-	* for disposal.
-	*/
-	get() {
-		if (!this.isMounted()) return null;
-		const range = document.createRange();
-		range.setStartAfter(this.start);
-		range.setEndBefore(this.end);
-		return range.extractContents();
-	}
-	/** Returns the parent node if the slot is mounted, otherwise `null`. */
-	parent() {
-		return this.isMounted() ? this.start.parentNode : null;
-	}
-	/** Whether the slot's comment markers are attached to the DOM. */
-	isMounted() {
-		return this.start.parentNode === this.end.parentNode && !!this.start.parentNode;
-	}
-	isSame(element) {
-		return this.start.nextSibling === element && this.end === element.nextSibling;
-	}
-	/**
-	* Create a callable slot instance.
-	*
-	* The returned value is both a function and an object:
-	* - Call it to render the slot with optional default content.
-	* - Access `.set()`, `.parent()`, `.isMounted()` for slot management.
-	*
-	* @example
-	* ```ts
-	* const slot = createSlot();
-	* el.append(slot("default text"));  // mount with default
-	* slot.set(newElement);              // replace content
-	* ```
-	*/
-	static new() {
-		const instance = new Slot();
-		return new Proxy(instance.slot.bind(instance), {
-			apply(target, _thisArg, argArray) {
-				return target(...argArray);
-			},
-			get(_target, prop) {
-				return instance[prop];
-			},
-			getPrototypeOf() {
-				return Slot.prototype;
-			}
-		});
-	}
-};
-/** A callable slot — invoke to render, or access `.set()` / `.isMounted()` / `.parent()` for management. */
-/**
-* Symbol key for attaching a `Slots` instance to a custom element instance.
-* This prevent collisions with Element properties and are not meant to be treated as JSX children.
-*/
-const $slots = Symbol("slots");
-const $map = Symbol("map");
-const $keys = Symbol("keys");
-const $has = Symbol("has");
-/**
-* A keyed collection of slot instances.
-* Slots are pre-created from the provided keys and lazily created on first access for unknown keys.
-*/
-var Slots = class Slots {
-	[$map] = /* @__PURE__ */ new Map();
-	constructor(keys = []) {
-		for (const key of keys) this[$map].set(key, Slot.new());
-	}
-	[Symbol.iterator]() {
-		return this[$map][Symbol.iterator]();
-	}
-	[Symbol.toStringTag]() {
-		return "Slots";
-	}
-	[Symbol.hasInstance](instance) {
-		return instance instanceof Slots;
-	}
-	[$has](key) {
-		return this[$map].has(key);
-	}
-	/** Check whether a slot with the given key exists. */
-	static has(slots, key) {
-		return slots[$has](key);
-	}
-	[$keys]() {
-		return this[$map].keys();
-	}
-	/** Iterate over all registered slot keys. */
-	static keys(slots) {
-		return slots[$keys]();
-	}
-	static new(keys) {
-		const instance = new Slots(keys);
-		return new Proxy(instance, { get(target, prop, receiver) {
-			if (typeof prop === "string" && target[$map].has(prop)) return target[$map].get(prop);
-			return Reflect.get(target, prop, receiver);
-		} });
-	}
-};
-//#endregion
+import { n as Slot, r as Slots, t as $slots } from "./slot-Cydy7-0L.mjs";
 export { $slots, Slot, Slots };