create-nuclo 0.1.1

package/templates/basic/node_modules/nuclo/types/html/tags.d.ts

@@ -0,0 +1,119 @@
+declare global {
+  // HTML tags
+  export const a: ExpandedElementBuilder<"a">;
+  export const abbr: ExpandedElementBuilder<"abbr">;
+  export const address: ExpandedElementBuilder<"address">;
+  export const article: ExpandedElementBuilder<"article">;
+  export const aside: ExpandedElementBuilder<"aside">;
+  export const audio: ExpandedElementBuilder<"audio">;
+  export const b: ExpandedElementBuilder<"b">;
+  export const bdi: ExpandedElementBuilder<"bdi">;
+  export const bdo: ExpandedElementBuilder<"bdo">;
+  export const blockquote: ExpandedElementBuilder<"blockquote">;
+  export const body: ExpandedElementBuilder<"body">;
+  export const button: ExpandedElementBuilder<"button">;
+  export const canvas: ExpandedElementBuilder<"canvas">;
+  export const caption: ExpandedElementBuilder<"caption">;
+  export const cite: ExpandedElementBuilder<"cite">;
+  export const code: ExpandedElementBuilder<"code">;
+  export const colgroup: ExpandedElementBuilder<"colgroup">;
+  export const data: ExpandedElementBuilder<"data">;
+  export const datalist: ExpandedElementBuilder<"datalist">;
+  export const dd: ExpandedElementBuilder<"dd">;
+  export const del: ExpandedElementBuilder<"del">;
+  export const details: ExpandedElementBuilder<"details">;
+  export const dfn: ExpandedElementBuilder<"dfn">;
+  export const dialog: ExpandedElementBuilder<"dialog">;
+  export const div: ExpandedElementBuilder<"div">;
+  export const dl: ExpandedElementBuilder<"dl">;
+  export const dt: ExpandedElementBuilder<"dt">;
+  export const em: ExpandedElementBuilder<"em">;
+  export const fieldset: ExpandedElementBuilder<"fieldset">;
+  export const figcaption: ExpandedElementBuilder<"figcaption">;
+  export const figure: ExpandedElementBuilder<"figure">;
+  export const footer: ExpandedElementBuilder<"footer">;
+  export const form: ExpandedElementBuilder<"form">;
+  export const h1: ExpandedElementBuilder<"h1">;
+  export const h2: ExpandedElementBuilder<"h2">;
+  export const h3: ExpandedElementBuilder<"h3">;
+  export const h4: ExpandedElementBuilder<"h4">;
+  export const h5: ExpandedElementBuilder<"h5">;
+  export const h6: ExpandedElementBuilder<"h6">;
+  export const head: ExpandedElementBuilder<"head">;
+  export const header: ExpandedElementBuilder<"header">;
+  export const hgroup: ExpandedElementBuilder<"hgroup">;
+  export const html: ExpandedElementBuilder<"html">;
+  export const i: ExpandedElementBuilder<"i">;
+  export const iframe: ExpandedElementBuilder<"iframe">;
+  export const ins: ExpandedElementBuilder<"ins">;
+  export const kbd: ExpandedElementBuilder<"kbd">;
+  export const label: ExpandedElementBuilder<"label">;
+  export const legend: ExpandedElementBuilder<"legend">;
+  export const li: ExpandedElementBuilder<"li">;
+  export const main: ExpandedElementBuilder<"main">;
+  export const map: ExpandedElementBuilder<"map">;
+  export const mark: ExpandedElementBuilder<"mark">;
+  export const menu: ExpandedElementBuilder<"menu">;
+  export const meter: ExpandedElementBuilder<"meter">;
+  export const nav: ExpandedElementBuilder<"nav">;
+  export const noscript: ExpandedElementBuilder<"noscript">;
+  export const object: ExpandedElementBuilder<"object">;
+  export const ol: ExpandedElementBuilder<"ol">;
+  export const optgroup: ExpandedElementBuilder<"optgroup">;
+  export const option: ExpandedElementBuilder<"option">;
+  export const output: ExpandedElementBuilder<"output">;
+  export const p: ExpandedElementBuilder<"p">;
+  export const picture: ExpandedElementBuilder<"picture">;
+  export const pre: ExpandedElementBuilder<"pre">;
+  export const progress: ExpandedElementBuilder<"progress">;
+  export const q: ExpandedElementBuilder<"q">;
+  export const rp: ExpandedElementBuilder<"rp">;
+  export const rt: ExpandedElementBuilder<"rt">;
+  export const ruby: ExpandedElementBuilder<"ruby">;
+  export const s: ExpandedElementBuilder<"s">;
+  export const samp: ExpandedElementBuilder<"samp">;
+  export const script: ExpandedElementBuilder<"script">;
+  export const search: ExpandedElementBuilder<"search">;
+  export const section: ExpandedElementBuilder<"section">;
+  export const select: ExpandedElementBuilder<"select">;
+  export const slot: ExpandedElementBuilder<"slot">;
+  export const small: ExpandedElementBuilder<"small">;
+  export const span: ExpandedElementBuilder<"span">;
+  export const strong: ExpandedElementBuilder<"strong">;
+  export const style: ExpandedElementBuilder<"style">;
+  export const sub: ExpandedElementBuilder<"sub">;
+  export const summary: ExpandedElementBuilder<"summary">;
+  export const sup: ExpandedElementBuilder<"sup">;
+  export const table: ExpandedElementBuilder<"table">;
+  export const tbody: ExpandedElementBuilder<"tbody">;
+  export const td: ExpandedElementBuilder<"td">;
+  export const template: ExpandedElementBuilder<"template">;
+  export const textarea: ExpandedElementBuilder<"textarea">;
+  export const tfoot: ExpandedElementBuilder<"tfoot">;
+  export const th: ExpandedElementBuilder<"th">;
+  export const thead: ExpandedElementBuilder<"thead">;
+  export const time: ExpandedElementBuilder<"time">;
+  export const title: ExpandedElementBuilder<"title">;
+  export const tr: ExpandedElementBuilder<"tr">;
+  export const u: ExpandedElementBuilder<"u">;
+  export const ul: ExpandedElementBuilder<"ul">;
+  export const var_: ExpandedElementBuilder<"var">;
+  export const video: ExpandedElementBuilder<"video">;
+
+  // Self-closing HTML tags (cannot have children)
+  export const area: ExpandedElementBuilder<"area">;
+  export const base: ExpandedElementBuilder<"base">;
+  export const br: ExpandedElementBuilder<"br">;
+  export const col: ExpandedElementBuilder<"col">;
+  export const embed: ExpandedElementBuilder<"embed">;
+  export const hr: ExpandedElementBuilder<"hr">;
+  export const img: ExpandedElementBuilder<"img">;
+  export const input: ExpandedElementBuilder<"input">;
+  export const link: ExpandedElementBuilder<"link">;
+  export const meta: ExpandedElementBuilder<"meta">;
+  export const source: ExpandedElementBuilder<"source">;
+  export const track: ExpandedElementBuilder<"track">;
+  export const wbr: ExpandedElementBuilder<"wbr">;
+}
+
+export {};

package/templates/basic/node_modules/nuclo/types/index.d.ts

@@ -0,0 +1,137 @@
+// Import all organized type definitions
+import "./core/base";
+import "./svg/base";
+import "./html/tags";
+import "./svg/tags";
+import "./features/list";
+import "./features/when";
+import "./features/update";
+import "./features/scope";
+import "./features/on";
+import "./features/render";
+import "./features/style";
+
+// ---------------------------------------------------------------------------
+// Module export surface — mirrors the runtime exports of src/index.ts so that
+// module-style consumers (import { render } from "nuclo") get the same types
+// as global-style consumers (import "nuclo"). Keep in sync with src/index.ts.
+// ---------------------------------------------------------------------------
+
+// Runtime bootstrap / tag registry
+export function initializeRuntime(): void;
+export function registerGlobalTagBuilders(target?: Record<string, unknown>): void;
+export const HTML_TAGS: ReadonlyArray<ElementTagName>;
+export const SVG_TAGS: ReadonlyArray<SVGTagName>;
+export const SELF_CLOSING_TAGS: ReadonlyArray<ElementTagName>;
+export function createHtmlTagBuilder<TTagName extends ElementTagName>(
+  tagName: TTagName,
+): ExpandedElementBuilder<TTagName>;
+export function createSvgTagBuilder<TTagName extends SVGTagName>(
+  tagName: TTagName,
+): ExpandedSVGElementBuilder<TTagName>;
+
+// Modifier application
+export function applyNodeModifier<TTagName extends ElementTagName>(
+  parent: ExpandedElement<TTagName>,
+  modifier: NodeModLike<TTagName>,
+  index: number,
+): Node | null;
+export function applyAttributes<TTagName extends ElementTagName>(
+  element: ExpandedElement<TTagName>,
+  attributes: ExpandedElementAttributes<TTagName>,
+  mergeClassName?: boolean,
+): void;
+export function createHtmlElementWithModifiers<TTagName extends ElementTagName>(
+  tagName: TTagName,
+  modifiers: ReadonlyArray<NodeModLike<TTagName>>,
+): ExpandedElement<TTagName>;
+export function createSvgElementWithModifiers<TTagName extends SVGTagName>(
+  tagName: TTagName,
+  modifiers: ReadonlyArray<SVGElementModifierLike<TTagName>>,
+): SVGElementTagNameMap[TTagName];
+
+// Core primitives (same signatures as the globals)
+export function list<T, TTagName extends ElementTagName = ElementTagName>(
+  itemsProvider: ListItemsProvider<T>,
+  render: ListRenderFunction<T, TTagName>,
+): ListModifier<TTagName>;
+export function when<TTagName extends ElementTagName = ElementTagName>(
+  condition: WhenCondition,
+  ...content: WhenContent<TTagName>[]
+): WhenBuilder<TTagName>;
+export function update(...scopeIds: string[]): void;
+export function scope<TTagName extends ElementTagName = ElementTagName>(
+  ...ids: string[]
+): NodeModFn<TTagName>;
+export function render<TTagName extends ElementTagName = ElementTagName>(
+  nodeModFn: NodeModFn<TTagName>,
+  parent?: Element,
+  index?: number,
+): ExpandedElement<TTagName>;
+export function hydrate<TTagName extends ElementTagName = ElementTagName>(
+  nodeModFn: NodeModFn<TTagName>,
+  parent?: Element,
+): ExpandedElement<TTagName>;
+
+// on() helper (same overloads as the global)
+export function on<K extends keyof HTMLElementEventMap, TTagName extends ElementTagName = ElementTagName>(
+  type: K,
+  listener: TypedEventListener<HTMLElementTagNameMap[TTagName], HTMLElementEventMap[K]>,
+  options?: boolean | AddEventListenerOptions
+): NodeModFn<TTagName>;
+export function on<K extends string, E extends Event = Event, TTagName extends ElementTagName = ElementTagName>(
+  type: K,
+  listener: TypedEventListener<HTMLElementTagNameMap[TTagName], E>,
+  options?: boolean | AddEventListenerOptions
+): NodeModFn<TTagName>;
+
+// DOM helpers
+export function appendChildren(
+  parent: Element | Node,
+  ...children: Array<Element | Node | string | null | undefined>
+): Element | Node;
+export function createComment(text: string): Comment | null;
+export function createConditionalComment(tagName: string, suffix?: string): Comment | null;
+export function replaceNodeSafely(oldNode: Node, newNode: Node): boolean;
+
+// Type guards / environment
+export function isBoolean(value: unknown): value is boolean;
+export function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+export function isNode<T>(value: T): value is T & Node;
+export function isObject(value: unknown): value is object;
+export function isPrimitive(value: unknown): value is Primitive;
+export function isTagLike<T>(value: T): value is T & { tagName?: string };
+export function isZeroArityFunction(value: unknown): value is () => unknown;
+export const isBrowser: boolean;
+
+// Styling (themeless default instance + themed factory)
+export function createCss<const T extends ThemeConfig>(theme?: T): CssInstance<T>;
+export function css(style: Style<object>): StyleResult;
+export function cx(...inputs: ClassInput[]): StyleResult;
+export function variants<const V extends VariantDefinitions<object>>(
+  config: VariantsConfig<object, V>,
+): VariantsFn<V>;
+export function keyframes(frames: KeyframeFrames<object>): string;
+export function globalStyle(selector: string, style: FlatStyle<object>): void;
+export function getCssText(): string;
+export function resetStyles(): void;
+export function setSSRCollector(fn: ((rule: string) => void) | null): void;
+
+// Styling types (same names as the globals, importable as module types)
+export type {
+  ClassInput,
+  CssInstance,
+  CSSProperties,
+  FlatStyle,
+  KeyframeFrames,
+  KeyframeStop,
+  Pseudo,
+  Size,
+  Style,
+  StyleResult,
+  ThemeConfig,
+  VariantDefinitions,
+  VariantProps,
+  VariantsConfig,
+  VariantsFn,
+} from "./style";

package/templates/basic/node_modules/nuclo/types/polyfill.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Type declarations for the `nuclo/polyfill` subpath.
+ *
+ * Hand-written (mirroring src/polyfill/index.ts) and shipped from `types/` so
+ * the subpath stays typed even when `dist/` holds only watch-mode JS bundles —
+ * `tsdown --watch` cleans dist and emits no declarations. Keep in sync with
+ * src/polyfill/*.
+ *
+ * The primary use is the side-effect import (`import "nuclo/polyfill"`), which
+ * installs document/Event/Node/Element/HTMLElement on globalThis when they are
+ * missing (Node.js SSR). The named exports below expose the polyfill classes.
+ */
+
+// Load the ambient nuclo globals (ExpandedElement, ElementTagName, …).
+import "./index";
+
+/** Minimal Node base used for instanceof checks in the Node.js polyfill. */
+export class NucloNode {
+	nodeType: number;
+	nodeName: string;
+	nodeValue: string | null;
+	parentNode: unknown;
+	textContent: string;
+	get childNodes(): NodeListOf<ChildNode>;
+}
+
+/** Text node polyfill. */
+export class NucloText {
+	nodeType: number;
+	nodeName: string;
+	data: string;
+	textContent: string;
+	parentNode: unknown;
+	nodeValue: string;
+	constructor(data: string);
+}
+
+/** Element polyfill: the subset of the DOM Element surface nuclo SSR uses. */
+export class NucloElement extends NucloNode {
+	tagName: string;
+	children: unknown[];
+	className: string;
+	id: string;
+	namespaceURI?: string;
+	sheet?: CSSStyleSheet | null;
+	rawMods?: unknown[];
+	mods?: unknown[];
+	attributes: Map<string, string>;
+	style: CSSStyleDeclaration;
+	classList: DOMTokenList;
+	innerHTML: string;
+	constructor(tagName: string);
+	appendChild<T extends Node>(child: T): T;
+	insertBefore<T extends Node>(newNode: T, referenceNode: Node | null): T;
+	removeChild<T extends Node>(child: T): T;
+	replaceChild<T extends Node>(newChild: Node, oldChild: T): T;
+	setAttribute(name: string, value: string): void;
+	getAttribute(name: string): string | null;
+	removeAttribute(name: string): void;
+	hasAttribute(name: string): boolean;
+	addEventListener(type: string, listener: EventListener): void;
+	removeEventListener(type: string, listener: EventListener): void;
+	dispatchEvent(event: Event): boolean;
+	querySelector(selector: string): Element | null;
+	querySelectorAll(selector: string): NodeListOf<Element>;
+}
+
+/** Document polyfill backing `document` in Node.js. */
+export class NucloDocument {
+	head: ExpandedElement;
+	body: ExpandedElement;
+	createElement(tagName: string, options?: unknown): ExpandedElement;
+	createElementNS(namespace: string, tagName: string, options?: unknown): ExpandedElement;
+	createTextNode(data: string): Text;
+	createComment(data: string): Comment;
+	createDocumentFragment(): DocumentFragment;
+	querySelector(selector: string): Element | null;
+	querySelectorAll(selector: string): NodeListOf<Element>;
+	addEventListener(type: string, listener: EventListener, options?: boolean | AddEventListenerOptions): void;
+	removeEventListener(type: string, listener: EventListener, options?: boolean | AddEventListenerOptions): void;
+	dispatchEvent(event: Event): boolean;
+	contains(node: Node): boolean;
+}
+
+/** Event polyfill (structurally compatible with the DOM Event interface). */
+export class NucloEvent implements Event {
+	type: string;
+	bubbles: boolean;
+	cancelable: boolean;
+	composed: boolean;
+	currentTarget: EventTarget | null;
+	defaultPrevented: boolean;
+	eventPhase: number;
+	isTrusted: boolean;
+	target: EventTarget | null;
+	timeStamp: number;
+	readonly AT_TARGET: 2;
+	readonly BUBBLING_PHASE: 3;
+	readonly CAPTURING_PHASE: 1;
+	readonly NONE: 0;
+	returnValue: boolean;
+	srcElement: EventTarget | null;
+	cancelBubble: boolean;
+	constructor(type: string, eventInitDict?: EventInit);
+	composedPath(): EventTarget[];
+	initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
+	preventDefault(): void;
+	stopImmediatePropagation(): void;
+	stopPropagation(): void;
+}
+
+/** CustomEvent polyfill. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class NucloCustomEvent<T = any> extends NucloEvent implements CustomEvent<T> {
+	detail: T;
+	constructor(type: string, eventInitDict?: CustomEventInit<T>);
+	initCustomEvent(type: string, bubbles?: boolean, cancelable?: boolean, detail?: T): void;
+}
+
+/** The active document: the browser global when present, else the polyfill. */
+export const document: Document | NucloDocument;
+/** The active Event constructor: the browser global when present, else the polyfill. */
+export const Event: typeof globalThis.Event | typeof NucloEvent;
+/** The active CustomEvent constructor: the browser global when present, else the polyfill. */
+export const CustomEvent: typeof globalThis.CustomEvent | typeof NucloCustomEvent;
+/** Alias of NucloNode (installed as globalThis.Node when missing). */
+export const Node: typeof NucloNode;
+/** Alias of NucloElement (installed as globalThis.Element when missing). */
+export const Element: typeof NucloElement;
+/** Alias of NucloElement (installed as globalThis.HTMLElement when missing). */
+export const HTMLElement: typeof NucloElement;

package/templates/basic/node_modules/nuclo/types/ssr.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Type declarations for the `nuclo/ssr` subpath.
+ *
+ * Hand-written (mirroring src/ssr/index.ts) and shipped from `types/` so the
+ * subpath stays typed even when `dist/` holds only watch-mode JS bundles —
+ * `tsdown --watch` cleans dist and emits no declarations. Keep in sync with
+ * src/ssr/index.ts.
+ */
+
+// Load the ambient nuclo globals (NodeModFn, ElementTagName, tag builders, …)
+// so SSR-only consumers get them without importing the main entry.
+import "./index";
+
+/** Anything renderToString accepts: a component factory, a DOM node, or nothing. */
+export type RenderableInput =
+  | NodeModFn<ElementTagName>
+  | Element
+  | Node
+  | null
+  | undefined;
+
+/**
+ * Renders a Nuclo component (or DOM node) to an HTML string.
+ * Text children keep their `<!-- text-N -->` markers so the output is hydratable.
+ */
+export function renderToString(input: RenderableInput): string;
+
+/** Renders multiple Nuclo components to HTML strings. */
+export function renderManyToString(inputs: RenderableInput[]): string[];
+
+/** Renders a Nuclo component wrapped in a container element. */
+export function renderToStringWithContainer(
+  input: RenderableInput,
+  containerTag?: string,
+  containerAttrs?: Record<string, string>,
+): string;
+
+/**
+ * Install a hook receiving every newly minted CSS rule (wrapped in its
+ * at-rule, if any). Installed once at server startup; pass null to remove.
+ */
+export function setSSRCollector(fn: ((rule: string) => void) | null): void;
+
+/** Serialize every registered atomic CSS rule (for a <style> tag in SSR output). */
+export function getCssText(): string;