@rooted/elements 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/elements.d.mts

@@ -43,13 +43,52 @@ type AriaIdReferenceProperties = {
  */
 type Aria = AriaStringProperties & AriaIdReferenceProperties;
 //#endregion
+//#region src/children.d.mts
+/**
+ * A single child of an element: a `Node` or a string of text. `undefined` and
+ * `null` are allowed too, and get skipped when the children are appended, so
+ * conditional children don't need a guard.
+ */
+export type ElementChild = Node | string | undefined | null;
+/**
+ * One or more children accepted by the `children` prop of every element
+ * created via `element()`, `create()` or `append()`.
+ *
+ * - A single `Node` or string is appended as-is.
+ * - An array is appended in order, skipping `undefined` and `null` entries.
+ *
+ * Because those entries are skipped, conditional children can be written
+ * inline with `optional()`. A plain ternary ending in `undefined` works too,
+ * it just reads worse.
+ *
+ * @example
+ * ```ts
+ * import { optional } from '@rooted/components'
+ *
+ * element('label', {
+ *   children: [
+ *     element('span', {
+ *       textContent: 'Name',
+ *     }),
+ *     optional(required,
+ *       element('abbr', {
+ *         title: 'required',
+ *         textContent: '*',
+ *       })
+ *     ),
+ *   ],
+ * })
+ * ```
+ */
+export type ElementChildren = Array<ElementChild> | ElementChild;
+//#endregion
 //#region src/classes.d.mts
 /**
  * A single CSS class value. Falsy variants (`undefined` and `null`) are
  * automatically filtered out when building a class list, so conditional
  * classes can be expressed without explicit guards.
  */
-type CssClass = string | undefined | null;
+export type CssClass = string | undefined | null;
 /**
  * One or more CSS class values accepted by the `classes` prop of every HTML
  * element created via `create()` or `append()`.
@@ -60,33 +99,77 @@ type CssClass = string | undefined | null;
  *
  * @see {@link cssClass} for composing conditional class names.
  */
-type CssClasses = Array<CssClass> | CssClass;
+export type CssClasses = Array<CssClass> | CssClass;
+/**
+ * Class names mapped to whether they apply. Only `true` includes the class,
+ * anything else leaves it out.
+ *
+ * Keys have to be strings, so this doesn't work with a `CssModule` value that
+ * TypeScript thinks might be `undefined`. Use the list form of
+ * {@link cssClasses} for those.
+ *
+ * @see {@link cssClasses} for the function that reads this.
+ */
+export type CssClassDictionary = Record<string, boolean | null | undefined>;
 /**
- * Returns `className` when `visible` is truthy, otherwise `undefined`.
+ * Returns `className` when `visible` is `true`, otherwise `undefined`.
  *
  * Designed to compose cleanly with {@link CssClasses}: falsy values are
  * filtered out automatically, so static and conditional classes can be mixed
- * in a single array without branching.
+ * in a single array without branching. Called with just a class name it
+ * returns that name, which is handy when the rest of the array is conditional.
  *
+ * The condition comes first, same as `optional()`.
+ *
+ * @param visible - When `true` the class is returned, any other value produces
+ *   `undefined`.
  * @param className - The CSS class to apply.
- * @param visible - When `true` (the default) the class is returned; any other
- *   value produces `undefined`.
  *
  * @example
  * ```ts
  * append('button', {
  *   classes: [
  *     'btn',
- *     cssClass('btn--active', isActive),
- *     cssClass('btn--disabled', isDisabled),
+ *     cssClass(isActive, 'btn--active'),
+ *     cssClass(isDisabled, 'btn--disabled'),
+ *   ],
+ * })
+ * ```
+ */
+export declare function cssClass(className: CssClass): CssClass;
+export declare function cssClass(visible: boolean | null | undefined, className: CssClass): CssClass;
+/**
+ * Joins several class names into one {@link CssClass}, dropping the falsy
+ * ones. Returns `undefined` when nothing is left, so the result disappears
+ * from a `classes` array instead of adding an empty string.
+ *
+ * Three ways to call it:
+ *
+ * - `cssClasses('a', 'b')` joins what you pass.
+ * - `cssClasses(visible, 'a', 'b')` joins them only when `visible` is `true`.
+ * - `cssClasses({ a: true, b: false })` keeps the keys mapped to `true`.
+ *
+ * Watch out for one overlap: a leading `undefined` or `null` is read as the
+ * condition, so `cssClasses(undefined, 'a')` is `undefined` and not `'a'`.
+ * A class name that might be `undefined`, like anything off a `CssModule`,
+ * belongs after the condition rather than first.
+ *
+ * @example
+ * ```ts
+ * append('button', {
+ *   classes: [
+ *     cssClasses(styles.button, styles.rounded),
+ *     cssClasses(isActive, styles.active, styles.raised),
+ *     cssClasses({
+ *       'btn--disabled': isDisabled,
+ *     }),
  *   ],
  * })
  * ```
  */
-declare function cssClass(className: string): CssClass;
-declare function cssClass(className: string, visible: boolean | null | undefined): CssClass;
-declare function cssClass(className: CssClass): CssClass;
-declare function cssClass(className: CssClass, visible: boolean | null | undefined): CssClass;
+export declare function cssClasses(visible: boolean | null | undefined, ...classNames: Array<CssClass>): CssClass;
+export declare function cssClasses(...classNames: Array<CssClass>): CssClass;
+export declare function cssClasses(classNames: CssClassDictionary): CssClass;
 //#endregion
 //#region src/element-type-utilities.d.mts
 type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? A : B;
@@ -100,7 +183,7 @@ type InlineStyle = { [K in keyof CSSStyleDeclaration as CSSStyleDeclaration[K] e
 type SanitizedHtmlProperties<TElement extends HTMLElement> = Omit<TElement, NonWritableKeys<TElement> | FunctionKeys<TElement> | Exclude<keyof ARIAMixin, 'role'> | OnHandlerKeys<TElement> | 'children' | 'className' | 'classList' | 'style'>;
 type HtmlElementPropertiesMapped<TElement extends HTMLElement> = Partial<SanitizedHtmlProperties<TElement>> & {
   [key: string]: unknown;
-  children?: Array<Node | string> | Node | string;
+  children?: ElementChildren;
   classes?: CssClasses;
   style?: InlineStyle;
   aria?: Aria;
@@ -130,7 +213,7 @@ type SvgElementPropertiesMapped<TElement extends SVGElement> = Partial<Sanitized
   [key: string]: unknown;
   classes?: CssClasses;
   style?: InlineStyle;
-  children?: Array<Node | string> | Node | string;
+  children?: ElementChildren;
   aria?: Aria;
   on?: ElementOnHandlers<TElement>;
 };
@@ -143,18 +226,18 @@ type SvgElementPropertiesMapped<TElement extends SVGElement> = Partial<Sanitized
 type SvgElementProperties<K extends SvgTagName> = SvgElementPropertiesMapped<SvgTagElement<K> & SVGElement>;
 //#endregion
 //#region src/element-factory.d.mts
-type ElementCreator = (key: string, ns?: string) => Element;
+export type ElementCreator = (key: string, ns?: string) => Element;
 /**
  * The overloaded function type returned by {@link createElementFactory}.
  * Accepts HTML or SVG tag names and returns the matching element type.
  */
-interface ElementCreatorFunction {
+export interface ElementCreatorFunction {
   (tag: 'svg', properties?: SvgElementProperties<'svg'>): SVGSVGElement;
   <K extends Exclude<SvgTagName, 'svg'>>(tag: K, properties?: SvgElementProperties<K>): SvgTagElement<K>;
   <K extends keyof HTMLElementTagNameMap>(tag: K, properties?: NoInfer<HtmlElementProperties<K>>): HTMLElementTagNameMap[K];
 }
-type ElementFactory = ElementCreatorFunction;
-declare function createElementFactory(constructElement: ElementCreator, signal: AbortSignal): ElementCreatorFunction;
+export type ElementFactory = ElementCreatorFunction;
+export declare function createElementFactory(constructElement: ElementCreator, signal: AbortSignal): ElementCreatorFunction;
 //#endregion
-export { type Aria, CssClass, CssClasses, ElementCreator, ElementCreatorFunction, ElementFactory, type HtmlElementProperties, type SvgElementProperties, type SvgTagElement, type SvgTagName, createElementFactory, cssClass };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+export type { Aria, HtmlElementProperties, SvgElementProperties, SvgTagElement, SvgTagName };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/elements.mjs

@@ -1,8 +1,24 @@
 //#region src/classes.mts
-function cssClass(className, visible = true) {
+function cssClass(...arguments_) {
+	if (arguments_.length === 1) return arguments_[0];
+	const [visible, className] = arguments_;
 	if (visible !== true) return;
 	return className;
 }
+function cssClasses(...arguments_) {
+	const [first, ...rest] = arguments_;
+	if (typeof first === "string") return joinClassNames([first, ...rest]);
+	if (first === void 0 || first === null || typeof first === "boolean") {
+		if (first !== true) return;
+		return joinClassNames(rest);
+	}
+	return joinClassNames(Object.entries(first).filter(([, visible]) => visible === true).map(([className]) => className));
+}
+function joinClassNames(classNames) {
+	const className = classNames.filter(Boolean).join(" ");
+	if (!className) return;
+	return className;
+}
 //#endregion
 //#region src/aria.mts
 const ariaIdReferenceAttributes = {
@@ -62,11 +78,11 @@ function buildClassList(classes) {
 	return { className: String(classes) };
 }
 function isWritableDomProperty(element, key) {
-	let proto = element;
-	while (proto) {
-		const desc = Object.getOwnPropertyDescriptor(proto, key);
+	let prototype = element;
+	while (prototype) {
+		const desc = Object.getOwnPropertyDescriptor(prototype, key);
 		if (desc) return !!(desc.writable || desc.set);
-		proto = Object.getPrototypeOf(proto);
+		prototype = Object.getPrototypeOf(prototype);
 	}
 	return false;
 }
@@ -107,10 +123,13 @@ function createElementFactory(constructElement, signal) {
 	return createElement;
 }
 function appendChildren(element, children) {
-	if (Array.isArray(children)) for (const child of children) element.append(child);
+	if (Array.isArray(children)) for (const child of children) {
+		if (child === void 0 || child === null) continue;
+		element.append(child);
+	}
 	else if (children) element.append(children);
 }
 //#endregion
-export { createElementFactory, cssClass };
+export { createElementFactory, cssClass, cssClasses };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"elements.mjs","names":[],"sources":["../src/classes.mts","../src/aria.mts","../src/element-factory.mts"],"sourcesContent":["/**\n * A single CSS class value. Falsy variants (`undefined` and `null`) are\n * automatically filtered out when building a class list, so conditional\n * classes can be expressed without explicit guards.\n */\nexport type CssClass = string | undefined | null\n\n/**\n * One or more CSS class values accepted by the `classes` prop of every HTML\n * element created via `create()` or `append()`.\n *\n * - A single string is used as-is.\n * - An array of {@link CssClass} values is joined with spaces after falsy\n *   entries are removed.\n *\n * @see {@link cssClass} for composing conditional class names.\n */\nexport type CssClasses = Array<CssClass> | CssClass\n\n/**\n * Returns `className` when `visible` is truthy, otherwise `undefined`.\n *\n * Designed to compose cleanly with {@link CssClasses}: falsy values are\n * filtered out automatically, so static and conditional classes can be mixed\n * in a single array without branching.\n *\n * @param className - The CSS class to apply.\n * @param visible - When `true` (the default) the class is returned; any other\n *   value produces `undefined`.\n *\n * @example\n * ```ts\n * append('button', {\n *   classes: [\n *     'btn',\n *     cssClass('btn--active', isActive),\n *     cssClass('btn--disabled', isDisabled),\n *   ],\n * })\n * ```\n */\nexport function cssClass(className: string): CssClass\nexport function cssClass(className: string, visible: boolean | null | undefined): CssClass\nexport function cssClass(className: CssClass): CssClass\nexport function cssClass(className: CssClass, visible: boolean | null | undefined): CssClass\nexport function cssClass(className: CssClass, visible: boolean | null | undefined = true): CssClass {\n\tif (visible !== true) return\n\treturn className\n}\n","type StripAria<S extends string> = S extends `aria${infer Rest}` ? Uncapitalize<Rest> : S\n\ntype AriaStringProperties = {\n\t[P in keyof ARIAMixin as ARIAMixin[P] extends string | null ? StripAria<string & P> : never]?: string | null\n}\n\n// Properties that only exist as Element[] in ARIAMixin. Accepts a string ID or an Element directly.\ntype AriaIdReferenceProperties = {\n\t/** {@inheritdoc ARIAMixin['ariaActiveDescendantElement']} */\n\tactiveDescendant?: string | Element | null\n\t/** {@inheritdoc ARIAMixin['ariaControlsElements']} */\n\tcontrols?: string | Element | null\n\t/** {@inheritdoc ARIAMixin['ariaDescribedByElements']} */\n\tdescribedBy?: string | Element | null\n\t/** {@inheritdoc ARIAMixin['ariaDetailsElements']} */\n\tdetails?: string | Element | null\n\t/** {@inheritdoc ARIAMixin['ariaErrorMessageElements']} */\n\terrorMessage?: string | Element | null\n\t/** {@inheritdoc ARIAMixin['ariaFlowToElements']} */\n\tflowTo?: string | Element | null\n\t/** {@inheritdoc ARIAMixin['ariaLabelledByElements']} */\n\tlabelledBy?: string | Element | null\n\t/** {@inheritdoc ARIAMixin['ariaOwnsElements']} */\n\towns?: string | Element | null\n}\n\n/**\n * Shape of the `aria` prop on `element(...)`. Accepts every ARIA attribute\n * defined on `ARIAMixin`, with the `aria` prefix stripped (so `aria-label`\n * becomes `label`, `aria-describedby` becomes `describedBy`).\n *\n * For ID-reference attributes (`aria-labelledby`, `aria-controls`, etc.) the\n * value can be a string ID or an `Element` reference. Element references are\n * set via the IDL reflection property when supported, falling back to the\n * attribute value otherwise.\n *\n * @example\n * ```ts\n * element('button', {\n *   aria: {\n *     label: 'Save',\n *     describedBy: helpTextElement,\n *     pressed: 'false',\n *   },\n * })\n * ```\n */\nexport type Aria = AriaStringProperties & AriaIdReferenceProperties\n\nconst ariaIdReferenceAttributes: Record<keyof AriaIdReferenceProperties, string> = {\n\tactiveDescendant: 'aria-activedescendant',\n\tcontrols: 'aria-controls',\n\tdescribedBy: 'aria-describedby',\n\tdetails: 'aria-details',\n\terrorMessage: 'aria-errormessage',\n\tflowTo: 'aria-flowto',\n\tlabelledBy: 'aria-labelledby',\n\towns: 'aria-owns',\n}\n\n// ariaActiveDescendantElement is singular; the rest take Element[]\nconst ariaIdReferenceElementProperties: Record<keyof AriaIdReferenceProperties, string> = {\n\tactiveDescendant: 'ariaActiveDescendantElement',\n\tcontrols: 'ariaControlsElements',\n\tdescribedBy: 'ariaDescribedByElements',\n\tdetails: 'ariaDetailsElements',\n\terrorMessage: 'ariaErrorMessageElements',\n\tflowTo: 'ariaFlowToElements',\n\tlabelledBy: 'ariaLabelledByElements',\n\towns: 'ariaOwnsElements',\n}\n\nfunction setProperty(element: Element, key: string, value: unknown): void {\n\t(element as unknown as Record<string, unknown>)[key] = value\n}\n\nexport function buildAriaProperties(aria: Aria | undefined, element: Element): void {\n\tif (!aria) return\n\tfor (const [key, value] of Object.entries(aria)) {\n\t\tif (!(key in ariaIdReferenceAttributes)) {\n\t\t\tconst domKey = `aria${key[0].toUpperCase()}${key.slice(1)}`\n\t\t\tsetProperty(element, domKey, value)\n\t\t\tcontinue\n\t\t}\n\t\tif (value === null || value === undefined) {\n\t\t\telement.removeAttribute(ariaIdReferenceAttributes[key as keyof AriaIdReferenceProperties])\n\t\t\tcontinue\n\t\t}\n\t\tif (value instanceof Element) {\n\t\t\tconst idlKey = ariaIdReferenceElementProperties[key as keyof AriaIdReferenceProperties]\n\t\t\tsetProperty(element, idlKey, idlKey.endsWith('Elements') ? [value] : value)\n\t\t\tcontinue\n\t\t}\n\t\telement.setAttribute(ariaIdReferenceAttributes[key as keyof AriaIdReferenceProperties], value)\n\t}\n}\n","import { ElementOnHandlers } from '@rooted/events'\n\nimport { type Aria, buildAriaProperties } from './aria.mts'\nimport { CssClasses } from './classes.mts'\nimport { HtmlElementProperties } from './html-element-properties.mts'\nimport { SvgElementProperties, SvgTagElement, SvgTagName } from './svg-element-properties.mts'\n\nfunction buildOnHandlers<TElement extends Element>(\n\ton: ElementOnHandlers<TElement> | undefined,\n\telement: TElement,\n\tsignal: AbortSignal,\n): void {\n\tif (!on) return\n\tfor (const [key, handler] of Object.entries(on)) {\n\t\tif (!handler) continue\n\t\telement.addEventListener(\n\t\t\tkey,\n\t\t\tevent => void (handler as (event?: Event) => void | Promise<void>)(event),\n\t\t\tsignal ? { signal } : undefined,\n\t\t)\n\t}\n}\n\nfunction buildClassList(classes: CssClasses | undefined) {\n\tif (classes === null || classes === undefined) return {}\n\tif (Array.isArray(classes)) return { className: classes.filter(Boolean).join(' ') }\n\n\treturn { className: String(classes) }\n}\n\nfunction isWritableDomProperty(element: Element, key: string): boolean {\n\tlet proto: object | null = element\n\twhile (proto) {\n\t\tconst desc = Object.getOwnPropertyDescriptor(proto, key)\n\t\tif (desc) return !!(desc.writable || desc.set)\n\t\tproto = Object.getPrototypeOf(proto) as object | null\n\t}\n\treturn false\n}\n\nexport type ElementCreator = (key: string, ns?: string) => Element\n\n/**\n * The overloaded function type returned by {@link createElementFactory}.\n * Accepts HTML or SVG tag names and returns the matching element type.\n */\nexport interface ElementCreatorFunction {\n\t(tag: 'svg', properties?: SvgElementProperties<'svg'>): SVGSVGElement\n\t<K extends Exclude<SvgTagName, 'svg'>>(tag: K, properties?: SvgElementProperties<K>): SvgTagElement<K>\n\t<K extends keyof HTMLElementTagNameMap>(tag: K, properties?: NoInfer<HtmlElementProperties<K>>): HTMLElementTagNameMap[K]\n}\n\nexport type ElementFactory = ElementCreatorFunction\nexport function createElementFactory(constructElement: ElementCreator, signal: AbortSignal): ElementCreatorFunction {\n\t/**\n\t * Creates an HTML or SVG element. The element is NOT appended to the\n\t * document; pass it to `append`, `prepend`, or set it as `children` of\n\t * another element.\n\t *\n\t * HTML tags use the regular `HTMLElementTagNameMap` keys. SVG tags use\n\t * `'svg'` for the root and `'svg:<name>'` for everything else (the prefix\n\t * keeps them from colliding with same-named HTML tags).\n\t *\n\t * Properties:\n\t * - `classes`: a class string or a {@link CssClasses} array. Falsy\n\t *   entries are filtered out.\n\t * - `aria`: ARIA attributes. Accepts string IDs or `Element` references\n\t *   for IDL reflection properties (e.g. `aria-labelledby`).\n\t * - `on`: an object of event handlers. Each listener is removed when the\n\t *   component unmounts.\n\t *   `children`: a single `Node` or an array; appended in order.\n\t * - Other props are set as DOM properties (so `htmlFor` not `for`,\n\t *   `readOnly` not `readonly`). On SVG, anything that isn't a writable\n\t *   DOM property falls back to `setAttribute`.\n\t *\n\t * @example\n\t * ```ts\n\t * const div = element('div', {\n\t *   classes: 'card',\n\t *   aria: { label: 'Card', labelledBy: headingEl },\n\t *   children: [\n\t *     element('h2', { textContent: 'Title' }),\n\t *     element('p',  { textContent: 'Body'  }),\n\t *   ],\n\t * })\n\t *\n\t * const icon = element('svg', {\n\t *   viewBox: '0 0 24 24',\n\t *   aria: { hidden: 'true' },\n\t *   children: element('svg:use', { href: spriteUrl }),\n\t * })\n\t * ```\n\t */\n\tfunction createElement(tag: 'svg', properties?: SvgElementProperties<'svg'>): SVGSVGElement\n\tfunction createElement<K extends Exclude<SvgTagName, 'svg'>>(tag: K, properties?: SvgElementProperties<K>): SvgTagElement<K>\n\tfunction createElement<KElement extends keyof HTMLElementTagNameMap>(tag: KElement, properties?: NoInfer<HtmlElementProperties<KElement>>): HTMLElementTagNameMap[KElement]\n\tfunction createElement(tag: string, properties?: Record<string, unknown>): Element {\n\t\tif (tag === 'svg' || tag.startsWith('svg:')) {\n\t\t\tconst actualTag = tag === 'svg' ? 'svg' : tag.slice(4)\n\t\t\tconst { classes, children, aria, on, style, ...attributes } = properties ?? {}\n\t\t\tconst newElement = constructElement(actualTag, 'http://www.w3.org/2000/svg') as SVGElement\n\n\t\t\tfor (const [key, value] of Object.entries(attributes)) {\n\t\t\t\tif (value === undefined || value === null) continue\n\t\t\t\tif (isWritableDomProperty(newElement, key)) {\n\t\t\t\t\t;(newElement as unknown as Record<string, unknown>)[key] = value\n\t\t\t\t}\n\t\t\t\telse if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {\n\t\t\t\t\tnewElement.setAttribute(key, String(value))\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tconst { className } = buildClassList(classes as CssClasses | undefined)\n\t\t\tif (className) newElement.setAttribute('class', className)\n\n\t\t\tif (style) Object.assign(newElement.style, style)\n\t\t\tbuildAriaProperties(aria as Aria | undefined, newElement)\n\t\t\tbuildOnHandlers(on as ElementOnHandlers<Element> | undefined, newElement, signal)\n\n\t\t\tappendChildren(newElement, children as Array<Node | string> | Node | string | undefined)\n\n\t\t\treturn newElement\n\t\t}\n\n\t\tconst { aria, children, classes, on, style, ...assignableProperties } = properties ?? {}\n\t\tconst newElement = constructElement(tag) as HTMLElement\n\n\t\tconst { className } = buildClassList(classes as CssClasses | undefined)\n\t\tif (className) newElement.className = className\n\n\t\tfor (const [key, value] of Object.entries(assignableProperties)) {\n\t\t\tif (value === undefined || value === null) continue\n\t\t\tif (isWritableDomProperty(newElement, key)) {\n\t\t\t\t;(newElement as unknown as Record<string, unknown>)[key] = value\n\t\t\t}\n\t\t\telse if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {\n\t\t\t\tnewElement.setAttribute(key, String(value))\n\t\t\t}\n\t\t}\n\n\t\tif (style) Object.assign(newElement.style, style)\n\t\tbuildAriaProperties(aria as Aria | undefined, newElement)\n\t\tbuildOnHandlers(on as ElementOnHandlers<HTMLElement> | undefined, newElement, signal)\n\t\tappendChildren(newElement, children as Array<Node | string> | Node | string | undefined)\n\n\t\treturn newElement\n\t}\n\n\treturn createElement\n}\n\nfunction appendChildren(element: Element, children: Array<Node | string> | Node | string | undefined): void {\n\tif (Array.isArray(children)) {\n\t\tfor (const child of children) {\n\t\t\telement.append(child)\n\t\t}\n\t}\n\telse if (children) {\n\t\telement.append(children)\n\t}\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"elements.mjs","names":[],"sources":["../src/classes.mts","../src/aria.mts","../src/element-factory.mts"],"sourcesContent":["/**\n * A single CSS class value. Falsy variants (`undefined` and `null`) are\n * automatically filtered out when building a class list, so conditional\n * classes can be expressed without explicit guards.\n */\nexport type CssClass = string | undefined | null\n\n/**\n * One or more CSS class values accepted by the `classes` prop of every HTML\n * element created via `create()` or `append()`.\n *\n * - A single string is used as-is.\n * - An array of {@link CssClass} values is joined with spaces after falsy\n *   entries are removed.\n *\n * @see {@link cssClass} for composing conditional class names.\n */\nexport type CssClasses = Array<CssClass> | CssClass\n\n/**\n * Class names mapped to whether they apply. Only `true` includes the class,\n * anything else leaves it out.\n *\n * Keys have to be strings, so this doesn't work with a `CssModule` value that\n * TypeScript thinks might be `undefined`. Use the list form of\n * {@link cssClasses} for those.\n *\n * @see {@link cssClasses} for the function that reads this.\n */\nexport type CssClassDictionary = Record<string, boolean | null | undefined>\n\n/**\n * Returns `className` when `visible` is `true`, otherwise `undefined`.\n *\n * Designed to compose cleanly with {@link CssClasses}: falsy values are\n * filtered out automatically, so static and conditional classes can be mixed\n * in a single array without branching. Called with just a class name it\n * returns that name, which is handy when the rest of the array is conditional.\n *\n * The condition comes first, same as `optional()`.\n *\n * @param visible - When `true` the class is returned, any other value produces\n *   `undefined`.\n * @param className - The CSS class to apply.\n *\n * @example\n * ```ts\n * append('button', {\n *   classes: [\n *     'btn',\n *     cssClass(isActive, 'btn--active'),\n *     cssClass(isDisabled, 'btn--disabled'),\n *   ],\n * })\n * ```\n */\nexport function cssClass(className: CssClass): CssClass\nexport function cssClass(visible: boolean | null | undefined, className: CssClass): CssClass\nexport function cssClass(...arguments_: [CssClass] | [boolean | null | undefined, CssClass]): CssClass {\n\tif (arguments_.length === 1) return arguments_[0]\n\n\tconst [visible, className] = arguments_\n\tif (visible !== true) return\n\treturn className\n}\n\n/**\n * Joins several class names into one {@link CssClass}, dropping the falsy\n * ones. Returns `undefined` when nothing is left, so the result disappears\n * from a `classes` array instead of adding an empty string.\n *\n * Three ways to call it:\n *\n * - `cssClasses('a', 'b')` joins what you pass.\n * - `cssClasses(visible, 'a', 'b')` joins them only when `visible` is `true`.\n * - `cssClasses({ a: true, b: false })` keeps the keys mapped to `true`.\n *\n * Watch out for one overlap: a leading `undefined` or `null` is read as the\n * condition, so `cssClasses(undefined, 'a')` is `undefined` and not `'a'`.\n * A class name that might be `undefined`, like anything off a `CssModule`,\n * belongs after the condition rather than first.\n *\n * @example\n * ```ts\n * append('button', {\n *   classes: [\n *     cssClasses(styles.button, styles.rounded),\n *     cssClasses(isActive, styles.active, styles.raised),\n *     cssClasses({\n *       'btn--disabled': isDisabled,\n *     }),\n *   ],\n * })\n * ```\n */\nexport function cssClasses(visible: boolean | null | undefined, ...classNames: Array<CssClass>): CssClass\nexport function cssClasses(...classNames: Array<CssClass>): CssClass\nexport function cssClasses(classNames: CssClassDictionary): CssClass\nexport function cssClasses(\n\t...arguments_: [CssClassDictionary] | [boolean | null | undefined, ...Array<CssClass>] | Array<CssClass>\n): CssClass {\n\tconst [first, ...rest] = arguments_\n\n\tif (typeof first === 'string') return joinClassNames([first, ...rest] as Array<CssClass>)\n\n\tif (first === undefined || first === null || typeof first === 'boolean') {\n\t\tif (first !== true) return\n\t\treturn joinClassNames(rest as Array<CssClass>)\n\t}\n\n\treturn joinClassNames(Object\n\t\t.entries(first)\n\t\t.filter(([, visible]) => visible === true)\n\t\t.map(([className]) => className))\n}\n\nfunction joinClassNames(classNames: Array<CssClass>): CssClass {\n\tconst className = classNames.filter(Boolean).join(' ')\n\tif (!className) return\n\treturn className\n}\n","type StripAria<S extends string> = S extends `aria${infer Rest}` ? Uncapitalize<Rest> : S\n\ntype AriaStringProperties = {\n\t[P in keyof ARIAMixin as ARIAMixin[P] extends string | null ? StripAria<string & P> : never]?: string | null\n}\n\n// Properties that only exist as Element[] in ARIAMixin. Accepts a string ID or an Element directly.\ntype AriaIdReferenceProperties = {\n\t/** {@inheritdoc ARIAMixin['ariaActiveDescendantElement']} */\n\tactiveDescendant?: string | Element | null\n\t/** {@inheritdoc ARIAMixin['ariaControlsElements']} */\n\tcontrols?: string | Element | null\n\t/** {@inheritdoc ARIAMixin['ariaDescribedByElements']} */\n\tdescribedBy?: string | Element | null\n\t/** {@inheritdoc ARIAMixin['ariaDetailsElements']} */\n\tdetails?: string | Element | null\n\t/** {@inheritdoc ARIAMixin['ariaErrorMessageElements']} */\n\terrorMessage?: string | Element | null\n\t/** {@inheritdoc ARIAMixin['ariaFlowToElements']} */\n\tflowTo?: string | Element | null\n\t/** {@inheritdoc ARIAMixin['ariaLabelledByElements']} */\n\tlabelledBy?: string | Element | null\n\t/** {@inheritdoc ARIAMixin['ariaOwnsElements']} */\n\towns?: string | Element | null\n}\n\n/**\n * Shape of the `aria` prop on `element(...)`. Accepts every ARIA attribute\n * defined on `ARIAMixin`, with the `aria` prefix stripped (so `aria-label`\n * becomes `label`, `aria-describedby` becomes `describedBy`).\n *\n * For ID-reference attributes (`aria-labelledby`, `aria-controls`, etc.) the\n * value can be a string ID or an `Element` reference. Element references are\n * set via the IDL reflection property when supported, falling back to the\n * attribute value otherwise.\n *\n * @example\n * ```ts\n * element('button', {\n *   aria: {\n *     label: 'Save',\n *     describedBy: helpTextElement,\n *     pressed: 'false',\n *   },\n * })\n * ```\n */\nexport type Aria = AriaStringProperties & AriaIdReferenceProperties\n\nconst ariaIdReferenceAttributes: Record<keyof AriaIdReferenceProperties, string> = {\n\tactiveDescendant: 'aria-activedescendant',\n\tcontrols: 'aria-controls',\n\tdescribedBy: 'aria-describedby',\n\tdetails: 'aria-details',\n\terrorMessage: 'aria-errormessage',\n\tflowTo: 'aria-flowto',\n\tlabelledBy: 'aria-labelledby',\n\towns: 'aria-owns',\n}\n\n// ariaActiveDescendantElement is singular; the rest take Element[]\nconst ariaIdReferenceElementProperties: Record<keyof AriaIdReferenceProperties, string> = {\n\tactiveDescendant: 'ariaActiveDescendantElement',\n\tcontrols: 'ariaControlsElements',\n\tdescribedBy: 'ariaDescribedByElements',\n\tdetails: 'ariaDetailsElements',\n\terrorMessage: 'ariaErrorMessageElements',\n\tflowTo: 'ariaFlowToElements',\n\tlabelledBy: 'ariaLabelledByElements',\n\towns: 'ariaOwnsElements',\n}\n\nfunction setProperty(element: Element, key: string, value: unknown): void {\n\t(element as unknown as Record<string, unknown>)[key] = value\n}\n\nexport function buildAriaProperties(aria: Aria | undefined, element: Element): void {\n\tif (!aria) return\n\tfor (const [key, value] of Object.entries(aria)) {\n\t\tif (!(key in ariaIdReferenceAttributes)) {\n\t\t\tconst domKey = `aria${key[0].toUpperCase()}${key.slice(1)}`\n\t\t\tsetProperty(element, domKey, value)\n\t\t\tcontinue\n\t\t}\n\t\tif (value === null || value === undefined) {\n\t\t\telement.removeAttribute(ariaIdReferenceAttributes[key as keyof AriaIdReferenceProperties])\n\t\t\tcontinue\n\t\t}\n\t\tif (value instanceof Element) {\n\t\t\tconst idlKey = ariaIdReferenceElementProperties[key as keyof AriaIdReferenceProperties]\n\t\t\tsetProperty(element, idlKey, idlKey.endsWith('Elements') ? [value] : value)\n\t\t\tcontinue\n\t\t}\n\t\telement.setAttribute(ariaIdReferenceAttributes[key as keyof AriaIdReferenceProperties], value)\n\t}\n}\n","import { ElementOnHandlers } from '@rooted/events'\n\nimport { type Aria, buildAriaProperties } from './aria.mts'\nimport { ElementChildren } from './children.mts'\nimport { CssClasses } from './classes.mts'\nimport { HtmlElementProperties } from './html-element-properties.mts'\nimport { SvgElementProperties, SvgTagElement, SvgTagName } from './svg-element-properties.mts'\n\nfunction buildOnHandlers<TElement extends Element>(\n\ton: ElementOnHandlers<TElement> | undefined,\n\telement: TElement,\n\tsignal: AbortSignal,\n): void {\n\tif (!on) return\n\tfor (const [key, handler] of Object.entries(on)) {\n\t\tif (!handler) continue\n\t\telement.addEventListener(\n\t\t\tkey,\n\t\t\tevent => void (handler as (event?: Event) => void | Promise<void>)(event),\n\t\t\tsignal ? { signal } : undefined,\n\t\t)\n\t}\n}\n\nfunction buildClassList(classes: CssClasses | undefined) {\n\tif (classes === null || classes === undefined) return {}\n\tif (Array.isArray(classes)) return { className: classes.filter(Boolean).join(' ') }\n\n\treturn { className: String(classes) }\n}\n\nfunction isWritableDomProperty(element: Element, key: string): boolean {\n\tlet prototype: object | null = element\n\twhile (prototype) {\n\t\tconst desc = Object.getOwnPropertyDescriptor(prototype, key)\n\t\tif (desc) return !!(desc.writable || desc.set)\n\t\tprototype = Object.getPrototypeOf(prototype) as object | null\n\t}\n\treturn false\n}\n\nexport type ElementCreator = (key: string, ns?: string) => Element\n\n/**\n * The overloaded function type returned by {@link createElementFactory}.\n * Accepts HTML or SVG tag names and returns the matching element type.\n */\nexport interface ElementCreatorFunction {\n\t(tag: 'svg', properties?: SvgElementProperties<'svg'>): SVGSVGElement\n\t<K extends Exclude<SvgTagName, 'svg'>>(tag: K, properties?: SvgElementProperties<K>): SvgTagElement<K>\n\t<K extends keyof HTMLElementTagNameMap>(tag: K, properties?: NoInfer<HtmlElementProperties<K>>): HTMLElementTagNameMap[K]\n}\n\nexport type ElementFactory = ElementCreatorFunction\nexport function createElementFactory(constructElement: ElementCreator, signal: AbortSignal): ElementCreatorFunction {\n\t/**\n\t * Creates an HTML or SVG element. The element is NOT appended to the\n\t * document; pass it to `append`, `prepend`, or set it as `children` of\n\t * another element.\n\t *\n\t * HTML tags use the regular `HTMLElementTagNameMap` keys. SVG tags use\n\t * `'svg'` for the root and `'svg:<name>'` for everything else (the prefix\n\t * keeps them from colliding with same-named HTML tags).\n\t *\n\t * Properties:\n\t * - `classes`: a class string or a {@link CssClasses} array. Falsy\n\t *   entries are filtered out.\n\t * - `aria`: ARIA attributes. Accepts string IDs or `Element` references\n\t *   for IDL reflection properties (e.g. `aria-labelledby`).\n\t * - `on`: an object of event handlers. Each listener is removed when the\n\t *   component unmounts.\n\t * - `children`: a single `Node` or an array; appended in order. `undefined`\n\t *   and `null` entries are skipped, same as `classes`.\n\t * - Other props are set as DOM properties (so `htmlFor` not `for`,\n\t *   `readOnly` not `readonly`). On SVG, anything that isn't a writable\n\t *   DOM property falls back to `setAttribute`.\n\t *\n\t * @example\n\t * ```ts\n\t * const div = element('div', {\n\t *   classes: 'card',\n\t *   aria: {\n\t *     label: 'Card',\n\t *     labelledBy: headingEl,\n\t *   },\n\t *   children: [\n\t *     element('h2', {\n\t *       textContent: 'Title',\n\t *     }),\n\t *     element('p', {\n\t *       textContent: 'Body',\n\t *     }),\n\t *   ],\n\t * })\n\t *\n\t * const icon = element('svg', {\n\t *   viewBox: '0 0 24 24',\n\t *   aria: {\n\t *     hidden: 'true',\n\t *   },\n\t *   children: element('svg:use', {\n\t *     href: spriteUrl,\n\t *   }),\n\t * })\n\t * ```\n\t */\n\tfunction createElement(tag: 'svg', properties?: SvgElementProperties<'svg'>): SVGSVGElement\n\tfunction createElement<K extends Exclude<SvgTagName, 'svg'>>(tag: K, properties?: SvgElementProperties<K>): SvgTagElement<K>\n\tfunction createElement<KElement extends keyof HTMLElementTagNameMap>(tag: KElement, properties?: NoInfer<HtmlElementProperties<KElement>>): HTMLElementTagNameMap[KElement]\n\tfunction createElement(tag: string, properties?: Record<string, unknown>): Element {\n\t\tif (tag === 'svg' || tag.startsWith('svg:')) {\n\t\t\tconst actualTag = tag === 'svg' ? 'svg' : tag.slice(4)\n\t\t\tconst { classes, children, aria, on, style, ...attributes } = properties ?? {}\n\t\t\tconst newElement = constructElement(actualTag, 'http://www.w3.org/2000/svg') as SVGElement\n\n\t\t\tfor (const [key, value] of Object.entries(attributes)) {\n\t\t\t\tif (value === undefined || value === null) continue\n\t\t\t\tif (isWritableDomProperty(newElement, key)) {\n\t\t\t\t\t;(newElement as unknown as Record<string, unknown>)[key] = value\n\t\t\t\t}\n\t\t\t\telse if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {\n\t\t\t\t\tnewElement.setAttribute(key, String(value))\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tconst { className } = buildClassList(classes as CssClasses | undefined)\n\t\t\tif (className) newElement.setAttribute('class', className)\n\n\t\t\tif (style) Object.assign(newElement.style, style)\n\t\t\tbuildAriaProperties(aria as Aria | undefined, newElement)\n\t\t\tbuildOnHandlers(on as ElementOnHandlers<Element> | undefined, newElement, signal)\n\n\t\t\tappendChildren(newElement, children as ElementChildren)\n\n\t\t\treturn newElement\n\t\t}\n\n\t\tconst { aria, children, classes, on, style, ...assignableProperties } = properties ?? {}\n\t\tconst newElement = constructElement(tag) as HTMLElement\n\n\t\tconst { className } = buildClassList(classes as CssClasses | undefined)\n\t\tif (className) newElement.className = className\n\n\t\tfor (const [key, value] of Object.entries(assignableProperties)) {\n\t\t\tif (value === undefined || value === null) continue\n\t\t\tif (isWritableDomProperty(newElement, key)) {\n\t\t\t\t;(newElement as unknown as Record<string, unknown>)[key] = value\n\t\t\t}\n\t\t\telse if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {\n\t\t\t\tnewElement.setAttribute(key, String(value))\n\t\t\t}\n\t\t}\n\n\t\tif (style) Object.assign(newElement.style, style)\n\t\tbuildAriaProperties(aria as Aria | undefined, newElement)\n\t\tbuildOnHandlers(on as ElementOnHandlers<HTMLElement> | undefined, newElement, signal)\n\t\tappendChildren(newElement, children as ElementChildren)\n\n\t\treturn newElement\n\t}\n\n\treturn createElement\n}\n\nfunction appendChildren(element: Element, children: ElementChildren): void {\n\tif (Array.isArray(children)) {\n\t\tfor (const child of children) {\n\t\t\tif (child === undefined || child === null) continue\n\t\t\telement.append(child)\n\t\t}\n\t}\n\telse if (children) {\n\t\telement.append(children)\n\t}\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rooted/elements",
-	"version": "1.0.0-alpha.7",
+	"version": "1.0.0-alpha.9",
 	"description": "Typed HTML and SVG element factory for the rooted framework",
 	"keywords": [
 		"web-components",
@@ -50,11 +50,11 @@
 		"extract-api": "rooted-development extract-api"
 	},
 	"peerDependencies": {
-		"@rooted/events": "1.0.0-alpha.7"
+		"@rooted/events": "1.0.0-alpha.9"
 	},
 	"devDependencies": {
 		"@rooted/development": "workspace:*",
-		"@rooted/events": "1.0.0-alpha.7",
-		"tsx": "^4.23.1"
+		"@rooted/events": "1.0.0-alpha.9",
+		"tsx": "^4.23.13"
 	}
 }

package/readme.md

@@ -9,16 +9,31 @@ Typed HTML and SVG element factory. Usable on its own, or as the DOM helper laye
 pnpm add @rooted/elements
 ```
 
+The package ships a factory builder rather than a ready-made `element`. You hand it the function that creates nodes and an `AbortSignal`, and you get the typed `element(...)` back. Inside a rooted component that's already done for you, `element` is on the mount context.
+
 ```ts
-import { element } from '@rooted/elements'
+import { createElementFactory, type ElementCreator } from '@rooted/elements'
+
+const controller = new AbortController()
+const createElement: ElementCreator = (tag, ns) => ns
+  ? document.createElementNS(ns, tag)
+  : document.createElement(tag)
+
+const element = createElementFactory(createElement, controller.signal)
 
 const card = element('div', {
   classes: 'card',
   children: [
-    element('h2', { textContent: 'Title' }),
-    element('p',  { textContent: 'Body'  }),
+    element('h2', {
+      textContent: 'Title',
+    }),
+    element('p', {
+      textContent: 'Body',
+    }),
   ],
 })
 ```
 
+The `ns` branch is what makes `element('svg', ...)` and the `svg:*` tags work, so don't drop it. Aborting the controller removes every listener registered through the `on` prop, which is how components clean up on unmount.
+
 More in the [elements page](https://github.com/Marvin-Brouwer/rooted/blob/main/docs/advanced/elements.md).