@rooted/elements 1.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marvin Brouwer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/elements.d.mts

@@ -0,0 +1,97 @@
+import { ElementOnHandlers } from '@rooted/events';
+
+type StripAria<S extends string> = S extends `aria${infer Rest}` ? Uncapitalize<Rest> : S;
+type AriaStringProperties = {
+    [P in keyof ARIAMixin as ARIAMixin[P] extends string | null ? StripAria<string & P> : never]?: string | null;
+};
+type AriaIdReferenceProperties = {
+    /** {@inheritdoc ARIAMixin['ariaActiveDescendantElement']} */
+    activeDescendant?: string | Element | null;
+    /** {@inheritdoc ARIAMixin['ariaControlsElements']} */
+    controls?: string | Element | null;
+    /** {@inheritdoc ARIAMixin['ariaDescribedByElements']} */
+    describedBy?: string | Element | null;
+    /** {@inheritdoc ARIAMixin['ariaDetailsElements']} */
+    details?: string | Element | null;
+    /** {@inheritdoc ARIAMixin['ariaErrorMessageElements']} */
+    errorMessage?: string | Element | null;
+    /** {@inheritdoc ARIAMixin['ariaFlowToElements']} */
+    flowTo?: string | Element | null;
+    /** {@inheritdoc ARIAMixin['ariaLabelledByElements']} */
+    labelledBy?: string | Element | null;
+    /** {@inheritdoc ARIAMixin['ariaOwnsElements']} */
+    owns?: string | Element | null;
+};
+type Aria = AriaStringProperties & AriaIdReferenceProperties;
+
+/**
+ * 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;
+/**
+ * One or more CSS class values accepted by the `classes` prop of every HTML
+ * element created via `create()` or `append()`.
+ *
+ * - A single string is used as-is.
+ * - An array of {@link CssClass} values is joined with spaces after falsy
+ *   entries are removed.
+ *
+ * @see {@link cssClass} for composing conditional class names.
+ */
+type CssClasses = Array<CssClass> | CssClass;
+/**
+ * Returns `className` when `visible` is truthy, 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.
+ *
+ * @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),
+ *   ],
+ * })
+ * ```
+ */
+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;
+
+type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? A : B;
+type NonWritableKeys<T> = {
+    [P in keyof T]-?: IfEquals<{
+        [Q in P]: T[P];
+    }, {
+        -readonly [Q in P]: T[P];
+    }, never, P>;
+}[keyof T];
+type FunctionKeys<T> = {
+    [P in keyof T]: NonNullable<T[P]> extends (...arguments_: never[]) => unknown ? P : never;
+}[keyof T];
+type OnHandlerKeys<T> = {
+    [P in keyof T]: P extends `on${string}` ? P : never;
+}[keyof T];
+type SanitizedHtmlProperties<TElement extends HTMLElement> = Omit<TElement, NonWritableKeys<TElement> | FunctionKeys<TElement> | Exclude<keyof ARIAMixin, 'role'> | OnHandlerKeys<TElement> | 'children' | 'className' | 'classList'>;
+type HtmlElementPropertiesMapped<TElement extends HTMLElement> = Partial<SanitizedHtmlProperties<TElement>> & {
+    children?: Array<Node | string> | Node | string;
+    classes?: CssClasses;
+    aria?: Aria;
+    on?: ElementOnHandlers<TElement>;
+};
+type HtmlElementProperties<KElement extends keyof HTMLElementTagNameMap> = HtmlElementPropertiesMapped<HTMLElementTagNameMap[KElement]>;
+type ElementCreator = (key: string) => HTMLElement;
+type ElementFactory = ReturnType<typeof createElementFactory>;
+declare function createElementFactory(constructElement: ElementCreator, signal: AbortSignal): <KElement extends keyof HTMLElementTagNameMap>(tag: KElement, properties?: NoInfer<HtmlElementProperties<KElement>>) => HTMLElementTagNameMap[KElement];
+
+export { type Aria, type CssClass, type CssClasses, type ElementCreator, type ElementFactory, createElementFactory, cssClass };

package/dist/elements.mjs

@@ -0,0 +1,96 @@
+// src/classes.mts
+function cssClass(className, visible = true) {
+  if (visible !== true) return;
+  return className;
+}
+
+// src/aria.mts
+var ariaIdReferenceAttributes = {
+  activeDescendant: "aria-activedescendant",
+  controls: "aria-controls",
+  describedBy: "aria-describedby",
+  details: "aria-details",
+  errorMessage: "aria-errormessage",
+  flowTo: "aria-flowto",
+  labelledBy: "aria-labelledby",
+  owns: "aria-owns"
+};
+var ariaIdReferenceElementProperties = {
+  activeDescendant: "ariaActiveDescendantElement",
+  controls: "ariaControlsElements",
+  describedBy: "ariaDescribedByElements",
+  details: "ariaDetailsElements",
+  errorMessage: "ariaErrorMessageElements",
+  flowTo: "ariaFlowToElements",
+  labelledBy: "ariaLabelledByElements",
+  owns: "ariaOwnsElements"
+};
+function setProperty(element, key, value) {
+  element[key] = value;
+}
+function buildAriaProperties(aria, element) {
+  if (!aria) return;
+  for (const [key, value] of Object.entries(aria)) {
+    if (!(key in ariaIdReferenceAttributes)) {
+      const domKey = `aria${key[0].toUpperCase()}${key.slice(1)}`;
+      setProperty(element, domKey, value);
+      continue;
+    }
+    if (value === null || value === void 0) {
+      element.removeAttribute(ariaIdReferenceAttributes[key]);
+      continue;
+    }
+    if (value instanceof Element) {
+      const idlKey = ariaIdReferenceElementProperties[key];
+      setProperty(element, idlKey, idlKey.endsWith("Elements") ? [value] : value);
+      continue;
+    }
+    element.setAttribute(ariaIdReferenceAttributes[key], value);
+  }
+}
+
+// src/element-factory.mts
+function buildOnHandlers(on, element, signal) {
+  if (!on) return;
+  for (const [key, handler] of Object.entries(on)) {
+    if (!handler) continue;
+    element.addEventListener(
+      key,
+      (event) => void handler(event),
+      signal ? { signal } : void 0
+    );
+  }
+}
+function buildClassList(classes) {
+  if (classes === null || classes === void 0) return {};
+  if (Array.isArray(classes)) return { className: classes.filter(Boolean).join(" ") };
+  return { className: String(classes) };
+}
+function createElementFactory(constructElement, signal) {
+  function createElement(tag, properties) {
+    const { aria, children, classes, on, ...assignableProperties } = properties ?? {};
+    const definedProperties = Object.fromEntries(
+      Object.entries(assignableProperties).filter(([, v]) => v !== void 0 && v !== null)
+    );
+    const newElement = Object.assign(
+      constructElement(tag),
+      definedProperties,
+      buildClassList(classes)
+    );
+    buildAriaProperties(aria, newElement);
+    buildOnHandlers(on, newElement, signal);
+    if (Array.isArray(children)) {
+      for (const child of children) {
+        newElement.append(child);
+      }
+    } else if (children) {
+      newElement.append(children);
+    }
+    return newElement;
+  }
+  return createElement.bind(void 0);
+}
+
+export { createElementFactory, cssClass };
+//# sourceMappingURL=elements.mjs.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/classes.mts","../src/aria.mts","../src/element-factory.mts"],"names":[],"mappings":"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","file":"elements.mjs","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\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'\n\ntype IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? A : B\ntype NonWritableKeys<T> = {\n\t[P in keyof T]-?: IfEquals<{ [Q in P]: T[P] }, { -readonly [Q in P]: T[P] }, never, P>\n}[keyof T]\ntype FunctionKeys<T> = {\n\t[P in keyof T]: NonNullable<T[P]> extends (...arguments_: never[]) => unknown ? P : never\n}[keyof T]\ntype OnHandlerKeys<T> = { [P in keyof T]: P extends `on${string}` ? P : never }[keyof T]\n\ntype SanitizedHtmlProperties<TElement extends HTMLElement> = Omit<\n\tTElement,\n\t| NonWritableKeys<TElement>\n\t| FunctionKeys<TElement>\n\t| Exclude<keyof ARIAMixin, 'role'>\n\t| OnHandlerKeys<TElement>\n\t| 'children' | 'className' | 'classList'\n>\ntype HtmlElementPropertiesMapped<TElement extends HTMLElement>\n\t= Partial<SanitizedHtmlProperties<TElement>>\n\t& {\n\t\tchildren?: Array<Node | string> | Node | string\n\t\tclasses?: CssClasses\n\t\taria?: Aria\n\t\ton?: ElementOnHandlers<TElement>\n\t}\n\ntype HtmlElementProperties<KElement extends keyof HTMLElementTagNameMap>\n\t= HtmlElementPropertiesMapped<HTMLElementTagNameMap[KElement]>\n\nfunction buildOnHandlers<TElement extends HTMLElement>(\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\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\nexport type ElementCreator = (key: string) => HTMLElement\nexport type ElementFactory = ReturnType<typeof createElementFactory>\nexport function createElementFactory(constructElement: ElementCreator, signal: AbortSignal) {\n\t/**\n\t * Creates a new HTML element. The element is **not** appended to the\n\t * document automatically.\n\t *\n\t * **`classes`** — accepts a single class string or a {@link CssClasses} array;\n\t * falsy entries are filtered out automatically.\n\t *\n\t * **DOM property names** — other properties are set via `Object.assign` and\n\t * must use DOM property names, not HTML attribute names:\n\t * | HTML attribute | DOM property |\n\t * |----------------|--------------|\n\t * | `for`          | `htmlFor`    |\n\t * | `readonly`     | `readOnly`   |\n\t *\n\t * **Children** — pass a single `Node` or an array of `Node`s via the\n\t * `children` property; they are appended in order.\n\t *\n\t * **Event listeners** — use the `on` prop with an object of event handlers.\n\t * Listeners are automatically removed when the component unmounts.\n\t *\n\t * **ARIA** — use the `aria` prop for ARIA attributes. Accepts string IDs or\n\t * `Element` references for IDL reflection properties.\n\t *\n\t * @example\n\t * ```ts\n\t * const div = create('div', {\n\t *   classes: 'card',\n\t *   aria: { label: 'Card', labelledBy: headingEl },\n\t *   children: [\n\t *     create('h2', { textContent: 'Title' }),\n\t *     create('p',  { textContent: 'Body'  }),\n\t *   ],\n\t * })\n\t * ```\n\t */\n\tfunction createElement<KElement extends keyof HTMLElementTagNameMap>(tag: KElement, properties?: NoInfer<HtmlElementProperties<KElement>>): HTMLElementTagNameMap[KElement] {\n\t\tconst { aria, children, classes, on, ...assignableProperties } = (properties ?? {})\n\t\tconst definedProperties = Object.fromEntries(Object\n\t\t\t.entries(assignableProperties)\n\t\t\t.filter(([, v]) => v !== undefined && v !== null),\n\t\t)\n\t\tconst newElement = Object.assign(\n\t\t\tconstructElement(tag) as HTMLElementTagNameMap[KElement],\n\t\t\tdefinedProperties,\n\t\t\tbuildClassList(classes),\n\t\t)\n\n\t\tbuildAriaProperties(aria, newElement)\n\t\tbuildOnHandlers(on, newElement, signal)\n\n\t\tif (Array.isArray(children)) {\n\t\t\tfor (const child of children) {\n\t\t\t\tnewElement.append(child)\n\t\t\t}\n\t\t}\n\t\telse if (children) {\n\t\t\tnewElement.append(children)\n\t\t}\n\n\t\treturn newElement as HTMLElementTagNameMap[KElement]\n\t}\n\n\treturn createElement.bind(undefined!)\n}\n"]}

package/dist/events.d.mts

@@ -0,0 +1 @@
+export * from '@rooted/events';

package/dist/events.mjs

@@ -0,0 +1,3 @@
+export * from '@rooted/events';
+//# sourceMappingURL=events.mjs.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsImZpbGUiOiJldmVudHMubWpzIiwic291cmNlc0NvbnRlbnQiOltdfQ==

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@rooted/elements",
+  "version": "1.0.0-alpha.0",
+  "description": "rooted — html element utilities",
+  "keywords": [
+    "web-components",
+    "custom-elements",
+    "framework-free",
+    "typescript",
+    "rooted"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Marvin-Brouwer/rooted.git",
+    "directory": "packages/elements"
+  },
+  "homepage": "https://github.com/Marvin-Brouwer/rooted#readme",
+  "bugs": "https://github.com/Marvin-Brouwer/rooted/issues",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "files": [
+    "dist",
+    "readme.md"
+  ],
+  "engines": {
+    "node": ">=22.0.0",
+    "pnpm": ">=10.0.0"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/elements.mjs",
+      "types": "./dist/elements.d.mjs"
+    },
+    "./events": {
+      "import": "./dist/events.mjs",
+      "types": "./dist/events.d.mjs"
+    }
+  },
+  "peerDependencies": {
+    "@rooted/events": "^1.0.0-alpha.0"
+  },
+  "devDependencies": {
+    "tsx": "^4.19.0",
+    "@rooted/development": "0.1.0",
+    "@rooted/events": "^1.0.0-alpha.0"
+  },
+  "scripts": {
+    "build": "pnpm build:ci",
+    "build:dev": "pnpm build:ci && rooted-development extract-api",
+    "build:ci": "tsup",
+    "watch": "tsup --watch --no-clean & rooted-development extract-api",
+    "clean": "rm -rf dist",
+    "extract-api": "rooted-development extract-api"
+  }
+}

package/readme.md

@@ -0,0 +1,7 @@
+# [`@rooted/elements`](https://www.npmjs.com/package/@rooted/elements)
+
+Html element utilities for the  [@rooted/*](https://github.com/Marvin-Brouwer/rooted?tab=readme-ov-file#rooted) framework.
+
+This library creates `HTMLElement`s and can also be used stand-alone. 
+
+> [!IMPORTANT] This package is still in `ALPHA`