@pyreon/ui-core 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Vit Bokisch
+
+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/README.md

@@ -0,0 +1,145 @@
+# @pyreon/ui-core
+
+Shared foundation for the Pyreon UI System ecosystem.
+
+Provides utility functions, a styling engine bridge, theme context, and HTML tag definitions used across all `@pyreon` packages. No external utility dependencies — all implementations are built-in with prototype pollution protection where applicable.
+
+## Installation
+
+```bash
+bun add @pyreon/ui-core
+```
+
+## API
+
+### Provider & Context
+
+```ts
+import { Provider, context, config, init } from '@pyreon/ui-core'
+```
+
+**Provider** wraps your app with a theme context. It bridges `@pyreon/styler`'s theming with the internal context system.
+
+```ts
+import { Provider } from '@pyreon/ui-core'
+
+Provider({
+  theme: { rootSize: 16, breakpoints: { xs: 0, md: 768 } },
+  children: [/* your app */],
+})
+```
+
+**config** — the styling engine singleton. Pyreon uses `@pyreon/styler` directly — no connector abstraction needed.
+
+```ts
+import { config } from '@pyreon/ui-core'
+
+// Access the engine from anywhere
+const { styled, css, keyframes } = config
+```
+
+### Utilities
+
+#### compose
+
+Right-to-left function composition.
+
+```ts
+import { compose } from '@pyreon/ui-core'
+
+const transform = compose(toUpperCase, trim, normalize)
+transform('  hello  ') // => 'HELLO'
+```
+
+#### render
+
+Flexible element renderer. Handles components, elements, primitives, and arrays.
+
+```ts
+import { render } from '@pyreon/ui-core'
+
+render('hello')           // => 'hello'
+render(MyComponent)       // => MyComponent({})
+render(null)              // => null
+```
+
+#### isEmpty
+
+Type-safe emptiness check. Returns `true` for `null`, `undefined`, `{}`, `[]`, and non-object primitives.
+
+```ts
+import { isEmpty } from '@pyreon/ui-core'
+
+isEmpty({})        // => true
+isEmpty([])        // => true
+isEmpty(null)      // => true
+isEmpty({ a: 1 }) // => false
+```
+
+#### omit / pick
+
+Create objects without or with only specified keys. Accept nullable inputs.
+
+```ts
+import { omit, pick } from '@pyreon/ui-core'
+
+omit({ a: 1, b: 2, c: 3 }, ['b'])    // => { a: 1, c: 3 }
+pick({ a: 1, b: 2, c: 3 }, ['a', 'b']) // => { a: 1, b: 2 }
+```
+
+#### set / get
+
+Nested property access and mutation by dot/bracket path. `set` has built-in prototype pollution protection — keys like `__proto__`, `constructor`, and `prototype` are blocked.
+
+```ts
+import { set, get } from '@pyreon/ui-core'
+
+const obj = {}
+set(obj, 'a.b.c', 42)    // => { a: { b: { c: 42 } } }
+get(obj, 'a.b.c')         // => 42
+get(obj, 'a.x', 'default') // => 'default'
+```
+
+#### merge
+
+Deep merge objects left-to-right. Only plain objects are recursed into; arrays are replaced wholesale. Prototype pollution keys are blocked.
+
+```ts
+import { merge } from '@pyreon/ui-core'
+
+merge({ a: { x: 1 } }, { a: { y: 2 } }) // => { a: { x: 1, y: 2 } }
+```
+
+#### throttle
+
+Limits function execution to at most once per wait period. Returns a throttled function with a `.cancel()` method.
+
+```ts
+import { throttle } from '@pyreon/ui-core'
+
+const throttled = throttle(handleResize, 200)
+window.addEventListener('resize', throttled)
+// cleanup: throttled.cancel()
+```
+
+### HTML Constants
+
+```ts
+import { HTML_TAGS, HTML_TEXT_TAGS } from '@pyreon/ui-core'
+```
+
+- **HTML_TAGS** — array of 100+ valid HTML tag names
+- **HTML_TEXT_TAGS** — array of text-content tags (h1–h6, p, span, strong, em, etc.)
+
+Both have corresponding TypeScript union types: `HTMLTags` and `HTMLTextTags`.
+
+## Peer Dependencies
+
+| Package | Version |
+| ------- | ------- |
+| @pyreon/core | >= 0.0.1 |
+| @pyreon/styler | >= 0.0.1 |
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,257 @@
+import * as _pyreon_styler0 from "@pyreon/styler";
+import { StyledFunction, css, keyframes, styled } from "@pyreon/styler";
+import * as _pyreon_core0 from "@pyreon/core";
+import { ComponentFn, VNodeChild } from "@pyreon/core";
+
+//#region src/compose.d.ts
+type ArityOneFn = (arg: any) => any;
+type PickLastInTuple<T extends any[]> = T extends [...rest: infer _U, argn: infer L] ? L : any;
+type FirstFnParameterType<T extends any[]> = Parameters<PickLastInTuple<T>>[any];
+type LastFnReturnType<T extends any[]> = ReturnType<T[0]>;
+declare const compose: <T extends ArityOneFn[]>(...fns: T) => (p: FirstFnParameterType<T>) => LastFnReturnType<T>;
+//#endregion
+//#region src/html/htmlElementAttrs.d.ts
+type Base = HTMLElement;
+interface HTMLElementAttrs {
+  a: HTMLAnchorElement;
+  abbr: Base;
+  address: Base;
+  area: HTMLAreaElement;
+  article: Base;
+  aside: Base;
+  audio: HTMLAudioElement;
+  b: Base;
+  bdi: Base;
+  bdo: Base;
+  big: Base;
+  blockquote: HTMLQuoteElement;
+  body: HTMLBodyElement;
+  br: HTMLBRElement;
+  button: HTMLButtonElement;
+  canvas: HTMLCanvasElement;
+  caption: Base;
+  cite: HTMLQuoteElement;
+  code: Base;
+  col: HTMLTableColElement;
+  colgroup: HTMLTableColElement;
+  data: HTMLDataElement;
+  datalist: HTMLDataListElement;
+  dd: Base;
+  del: HTMLModElement;
+  details: HTMLDetailsElement;
+  dfn: Base;
+  dialog: HTMLDialogElement;
+  div: HTMLDivElement;
+  dl: HTMLDListElement;
+  dt: Base;
+  em: Base;
+  embed: HTMLEmbedElement;
+  fieldset: HTMLFieldSetElement;
+  figcaption: Base;
+  figure: Base;
+  footer: Base;
+  form: HTMLFormElement;
+  h1: HTMLHeadingElement;
+  h2: HTMLHeadingElement;
+  h3: HTMLHeadingElement;
+  h4: HTMLHeadingElement;
+  h5: HTMLHeadingElement;
+  h6: HTMLHeadingElement;
+  header: Base;
+  hr: HTMLHRElement;
+  html: HTMLHtmlElement;
+  i: Base;
+  iframe: HTMLIFrameElement;
+  img: HTMLImageElement;
+  input: HTMLInputElement;
+  ins: HTMLModElement;
+  kbd: Base;
+  label: HTMLLabelElement;
+  legend: HTMLLegendElement;
+  li: HTMLLIElement;
+  main: Base;
+  map: HTMLMapElement;
+  mark: Base;
+  meter: HTMLMeterElement;
+  nav: Base;
+  object: HTMLObjectElement;
+  ol: HTMLOListElement;
+  optgroup: HTMLOptGroupElement;
+  option: HTMLOptionElement;
+  output: HTMLOutputElement;
+  p: HTMLParagraphElement;
+  picture: Base;
+  pre: HTMLPreElement;
+  progress: HTMLProgressElement;
+  q: HTMLQuoteElement;
+  rp: Base;
+  rt: Base;
+  ruby: Base;
+  s: Base;
+  samp: Base;
+  section: Base;
+  select: HTMLSelectElement;
+  small: Base;
+  source: HTMLSourceElement;
+  span: HTMLSpanElement;
+  strong: Base;
+  sub: Base;
+  summary: Base;
+  sup: Base;
+  svg: SVGSVGElement;
+  table: HTMLTableElement;
+  tbody: HTMLTableSectionElement;
+  td: HTMLTableCellElement;
+  template: HTMLTemplateElement;
+  textarea: HTMLTextAreaElement;
+  tfoot: HTMLTableSectionElement;
+  th: HTMLTableCellElement;
+  thead: HTMLTableSectionElement;
+  time: HTMLTimeElement;
+  tr: HTMLTableRowElement;
+  track: HTMLTrackElement;
+  u: Base;
+  ul: HTMLUListElement;
+  var: Base;
+  video: HTMLVideoElement;
+  wbr: Base;
+}
+//#endregion
+//#region src/html/htmlTags.d.ts
+declare const HTML_TAGS: readonly ["a", "abbr", "address", "area", "article", "aside", "audio", "b", "bdi", "bdo", "big", "blockquote", "body", "br", "button", "canvas", "caption", "cite", "code", "col", "colgroup", "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt", "em", "embed", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hr", "html", "i", "iframe", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "map", "mark", "meter", "nav", "object", "ol", "optgroup", "option", "output", "p", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "section", "select", "small", "source", "span", "strong", "sub", "summary", "sup", "svg", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "tr", "track", "u", "ul", "var", "video", "wbr"];
+declare const HTML_TEXT_TAGS: readonly ["abbr", "b", "bdi", "bdo", "big", "blockquote", "cite", "code", "del", "div", "dl", "dt", "em", "figcaption", "h1", "h2", "h3", "h4", "h5", "h6", "i", "ins", "kbd", "label", "legend", "li", "p", "pre", "q", "rp", "rt", "s", "small", "span", "strong", "sub", "summary", "sup", "time", "u"];
+type HTMLTags = (typeof HTML_TAGS)[number];
+type HTMLTextTags = (typeof HTML_TEXT_TAGS)[number];
+//#endregion
+//#region src/html/index.d.ts
+type HTMLTagAttrsByTag<T extends HTMLTags> = T extends HTMLTags ? HTMLElementAttrs[T] : Record<string, never>;
+//#endregion
+//#region src/config.d.ts
+/**
+ * Describes the shape of the CSS-in-JS engine.
+ * Pyreon uses @pyreon/styler directly — no connector abstraction needed.
+ * This type is kept for API compatibility with downstream packages.
+ */
+interface CSSEngineConnector {
+  css: typeof css;
+  styled: typeof styled;
+  keyframes: typeof keyframes;
+}
+interface PlatformConfig {
+  component: string | HTMLTags;
+  textComponent: string | HTMLTags;
+  createMediaQueries?: (props: {
+    breakpoints: Record<string, number>;
+    rootSize: number;
+    css: CSSEngineConnector["css"];
+  }) => Record<string, (...args: any[]) => any>;
+}
+type InitConfig = Partial<CSSEngineConnector & PlatformConfig>;
+/**
+ * Configuration singleton that bridges the UI system with the CSS engine.
+ * All packages reference config.css, config.styled, etc.
+ *
+ * In Pyreon, the engine is @pyreon/styler and is available immediately —
+ * no lazy initialization or connector pattern needed.
+ */
+declare class Configuration {
+  css: (strings: TemplateStringsArray, ...values: _pyreon_styler0.Interpolation[]) => _pyreon_styler0.CSSResult;
+  styled: StyledFunction;
+  keyframes: (strings: TemplateStringsArray, ...values: _pyreon_styler0.Interpolation[]) => {
+    readonly name: string;
+    toString(): string;
+  };
+  component: string | HTMLTags;
+  textComponent: string | HTMLTags;
+  createMediaQueries: PlatformConfig["createMediaQueries"];
+  init: (props: InitConfig) => void;
+}
+declare const config: Configuration;
+declare const init: (props: InitConfig) => void;
+//#endregion
+//#region src/types.d.ts
+interface Breakpoints {
+  [key: string]: number;
+}
+type BreakpointKeys = keyof Breakpoints;
+//#endregion
+//#region src/context.d.ts
+/**
+ * Internal context shared across all @pyreon packages.
+ * Carries the theme object plus any extra provider props.
+ */
+declare const context: _pyreon_core0.Context<any>;
+type Theme = Partial<{
+  rootSize: number;
+  breakpoints: Breakpoints;
+} & Record<string, any>>;
+type ProviderType = Partial<{
+  theme: Theme;
+  children: VNodeChild;
+} & Record<string, any>>;
+/**
+ * Provider that feeds the internal Pyreon context with the theme.
+ * When no theme is supplied, renders children directly.
+ */
+declare function Provider({
+  theme,
+  children,
+  ...props
+}: ProviderType): VNodeChild;
+//#endregion
+//#region src/hoistNonReactStatics.d.ts
+/**
+ * Copies non-framework static properties from a source component to a target.
+ *
+ * Pyreon equivalent of hoistNonReactStatics — simplified since Pyreon
+ * components are plain functions without React-specific statics like
+ * contextType, propTypes, getDerivedStateFromProps, etc.
+ */
+declare const hoistNonReactStatics: <T, S>(target: T, source: S, excludeList?: Record<string, true>) => T;
+//#endregion
+//#region src/isEmpty.d.ts
+type IsEmpty = <T extends Record<number | string, any> | any[] | null | undefined>(param: T) => T extends null | undefined ? true : keyof T extends never ? true : T extends T[] ? T[number] extends never ? true : false : false;
+declare const isEmpty: IsEmpty;
+//#endregion
+//#region src/isEqual.d.ts
+declare const isEqual: (a: unknown, b: unknown) => boolean;
+//#endregion
+//#region src/render.d.ts
+type RenderProps<T extends Record<string, unknown> | undefined> = (props: Partial<T>) => VNodeChild;
+/**
+ * Flexible element renderer that handles multiple content types:
+ * - Primitives (string, number) — returned as-is
+ * - Arrays — returned as-is
+ * - Component functions — created via h()
+ * - VNode objects — returned as-is (with props merged if provided)
+ * - Render props (functions) — called with attachProps
+ * - Falsy values — return null
+ */
+type Render = <T extends Record<string, any> | undefined>(content?: ComponentFn | string | VNodeChild | VNodeChild[] | RenderProps<T>, attachProps?: T) => VNodeChild;
+declare const render: Render;
+//#endregion
+//#region src/useStableValue.d.ts
+/**
+ * Returns a referentially stable version of `value`. The returned reference
+ * only changes when the value is no longer deeply equal to the previous one.
+ *
+ * Pyreon equivalent of the React useStableValue hook — uses a signal
+ * internally to hold the stable reference.
+ */
+declare const useStableValue: <T>(value: T) => T;
+//#endregion
+//#region src/utils.d.ts
+declare const omit: <T extends Record<string, any>>(obj: T | null | undefined, keys?: readonly (string | keyof T)[]) => Partial<T>;
+declare const pick: <T extends Record<string, any>>(obj: T | null | undefined, keys?: readonly (string | keyof T)[]) => Partial<T>;
+declare const get: (obj: any, path: string | string[], defaultValue?: any) => any;
+declare const set: (obj: Record<string, any>, path: string | string[], value: any) => Record<string, any>;
+declare const throttle: <T extends (...args: any[]) => any>(fn: T, wait?: number, options?: {
+  leading?: boolean;
+  trailing?: boolean;
+}) => T & {
+  cancel: () => void;
+};
+declare const merge: <T extends Record<string, any>>(target: T, ...sources: Record<string, any>[]) => T;
+//#endregion
+export { type BreakpointKeys, type Breakpoints, type CSSEngineConnector, type HTMLElementAttrs, type HTMLTagAttrsByTag, type HTMLTags, type HTMLTextTags, HTML_TAGS, HTML_TEXT_TAGS, type IsEmpty, Provider, type Render, compose, config, context, get, hoistNonReactStatics, init, isEmpty, isEqual, merge, omit, pick, render, set, throttle, useStableValue };
+//# sourceMappingURL=index2.d.ts.map

package/lib/index.js

@@ -0,0 +1,560 @@
+import { css, keyframes, styled } from "@pyreon/styler";
+import { createContext, h, onUnmount, popContext, pushContext } from "@pyreon/core";
+
+//#region src/compose.ts
+const compose = (...fns) => (p) => fns.reduceRight((acc, cur) => cur(acc), p);
+
+//#endregion
+//#region src/config.ts
+/**
+* Configuration singleton that bridges the UI system with the CSS engine.
+* All packages reference config.css, config.styled, etc.
+*
+* In Pyreon, the engine is @pyreon/styler and is available immediately —
+* no lazy initialization or connector pattern needed.
+*/
+var Configuration = class {
+	css = css;
+	styled = styled;
+	keyframes = keyframes;
+	component = "div";
+	textComponent = "span";
+	createMediaQueries = void 0;
+	init = (props) => {
+		if (props.css) this.css = props.css;
+		if (props.styled) this.styled = props.styled;
+		if (props.keyframes) this.keyframes = props.keyframes;
+		if (props.component) this.component = props.component;
+		if (props.textComponent) this.textComponent = props.textComponent;
+		if (props.createMediaQueries) this.createMediaQueries = props.createMediaQueries;
+	};
+};
+const config = new Configuration();
+const { init } = config;
+
+//#endregion
+//#region src/isEmpty.ts
+const isEmpty = ((param) => {
+	if (!param) return true;
+	if (typeof param !== "object") return true;
+	if (Array.isArray(param)) return param.length === 0;
+	return Object.keys(param).length === 0;
+});
+
+//#endregion
+//#region src/context.tsx
+/**
+* Internal context shared across all @pyreon packages.
+* Carries the theme object plus any extra provider props.
+*/
+const context = createContext({});
+/**
+* Provider that feeds the internal Pyreon context with the theme.
+* When no theme is supplied, renders children directly.
+*/
+function Provider({ theme, children, ...props }) {
+	if (isEmpty(theme) || !theme) return children ?? null;
+	const contextValue = {
+		theme,
+		...props
+	};
+	pushContext(new Map([[context.id, contextValue]]));
+	onUnmount(() => popContext());
+	return children ?? null;
+}
+
+//#endregion
+//#region src/hoistNonReactStatics.ts
+const KNOWN_STATICS = {
+	name: true,
+	length: true,
+	prototype: true,
+	caller: true,
+	callee: true,
+	arguments: true,
+	arity: true
+};
+const COMPONENT_STATICS = {
+	displayName: true,
+	defaultProps: true
+};
+/**
+* Copies non-framework static properties from a source component to a target.
+*
+* Pyreon equivalent of hoistNonReactStatics — simplified since Pyreon
+* components are plain functions without React-specific statics like
+* contextType, propTypes, getDerivedStateFromProps, etc.
+*/
+const hoistNonReactStatics = (target, source, excludeList) => {
+	if (typeof source === "string") return target;
+	const proto = Object.getPrototypeOf(source);
+	if (proto && proto !== Object.prototype) hoistNonReactStatics(target, proto, excludeList);
+	const keys = [...Object.getOwnPropertyNames(source), ...Object.getOwnPropertySymbols(source)];
+	for (const key of keys) {
+		const k = key;
+		if (KNOWN_STATICS[k] || excludeList?.[k] || COMPONENT_STATICS[k]) continue;
+		const descriptor = Object.getOwnPropertyDescriptor(source, key);
+		if (descriptor) try {
+			Object.defineProperty(target, key, descriptor);
+		} catch {}
+	}
+	return target;
+};
+
+//#endregion
+//#region src/html/htmlTags.ts
+const HTML_TAGS = [
+	"a",
+	"abbr",
+	"address",
+	"area",
+	"article",
+	"aside",
+	"audio",
+	"b",
+	"bdi",
+	"bdo",
+	"big",
+	"blockquote",
+	"body",
+	"br",
+	"button",
+	"canvas",
+	"caption",
+	"cite",
+	"code",
+	"col",
+	"colgroup",
+	"data",
+	"datalist",
+	"dd",
+	"del",
+	"details",
+	"dfn",
+	"dialog",
+	"div",
+	"dl",
+	"dt",
+	"em",
+	"embed",
+	"fieldset",
+	"figcaption",
+	"figure",
+	"footer",
+	"form",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"hr",
+	"html",
+	"i",
+	"iframe",
+	"img",
+	"input",
+	"ins",
+	"kbd",
+	"label",
+	"legend",
+	"li",
+	"main",
+	"map",
+	"mark",
+	"meter",
+	"nav",
+	"object",
+	"ol",
+	"optgroup",
+	"option",
+	"output",
+	"p",
+	"picture",
+	"pre",
+	"progress",
+	"q",
+	"rp",
+	"rt",
+	"ruby",
+	"s",
+	"samp",
+	"section",
+	"select",
+	"small",
+	"source",
+	"span",
+	"strong",
+	"sub",
+	"summary",
+	"sup",
+	"svg",
+	"table",
+	"tbody",
+	"td",
+	"template",
+	"textarea",
+	"tfoot",
+	"th",
+	"thead",
+	"time",
+	"tr",
+	"track",
+	"u",
+	"ul",
+	"var",
+	"video",
+	"wbr"
+];
+const HTML_TEXT_TAGS = [
+	"abbr",
+	"b",
+	"bdi",
+	"bdo",
+	"big",
+	"blockquote",
+	"cite",
+	"code",
+	"del",
+	"div",
+	"dl",
+	"dt",
+	"em",
+	"figcaption",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"i",
+	"ins",
+	"kbd",
+	"label",
+	"legend",
+	"li",
+	"p",
+	"pre",
+	"q",
+	"rp",
+	"rt",
+	"s",
+	"small",
+	"span",
+	"strong",
+	"sub",
+	"summary",
+	"sup",
+	"time",
+	"u"
+];
+
+//#endregion
+//#region src/isEqual.ts
+const isArrayEqual = (a, b) => {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (!isEqual(a[i], b[i])) return false;
+	return true;
+};
+const isObjectEqual = (a, b) => {
+	const aKeys = Object.keys(a);
+	if (aKeys.length !== Object.keys(b).length) return false;
+	for (const key of aKeys) {
+		if (!Object.hasOwn(b, key)) return false;
+		if (!isEqual(a[key], b[key])) return false;
+	}
+	return true;
+};
+const isEqual = (a, b) => {
+	if (Object.is(a, b)) return true;
+	if (typeof a !== typeof b || a == null || b == null || typeof a !== "object") return false;
+	if (Array.isArray(a)) return Array.isArray(b) && isArrayEqual(a, b);
+	if (Array.isArray(b)) return false;
+	return isObjectEqual(a, b);
+};
+
+//#endregion
+//#region src/render.tsx
+const render = (content, attachProps) => {
+	if (!content) return null;
+	const t = typeof content;
+	if (t === "string" || t === "number" || t === "boolean" || t === "bigint") return content;
+	if (Array.isArray(content)) return content;
+	if (typeof content === "function") return h(content, attachProps ?? {});
+	if (typeof content === "object" && content !== null) return content;
+	return content;
+};
+
+//#endregion
+//#region ../../node_modules/.bun/@pyreon+reactivity@0.3.1/node_modules/@pyreon/reactivity/lib/index.js
+let batchDepth = 0;
+let setA = /* @__PURE__ */ new Set();
+let pendingNotifications = setA;
+function isBatching() {
+	return batchDepth > 0;
+}
+function enqueuePendingNotification(notify) {
+	pendingNotifications.add(notify);
+}
+let activeEffect = null;
+const effectDeps = /* @__PURE__ */ new WeakMap();
+let _depsCollector = null;
+/**
+* Register the active effect as a subscriber of the given reactive source.
+* The subscriber Set is created lazily on the host — sources read only outside
+* effects never allocate a Set.
+*/
+function trackSubscriber(host) {
+	if (activeEffect) {
+		if (!host._s) host._s = /* @__PURE__ */ new Set();
+		const subscribers = host._s;
+		subscribers.add(activeEffect);
+		if (_depsCollector) _depsCollector.push(subscribers);
+		else {
+			let deps = effectDeps.get(activeEffect);
+			if (!deps) {
+				deps = /* @__PURE__ */ new Set();
+				effectDeps.set(activeEffect, deps);
+			}
+			deps.add(subscribers);
+		}
+	}
+}
+function notifySubscribers(subscribers) {
+	if (subscribers.size === 0) return;
+	if (subscribers.size === 1) {
+		const sub = subscribers.values().next().value;
+		if (isBatching()) enqueuePendingNotification(sub);
+		else sub();
+		return;
+	}
+	if (isBatching()) for (const sub of subscribers) enqueuePendingNotification(sub);
+	else {
+		const originalSize = subscribers.size;
+		let i = 0;
+		for (const sub of subscribers) {
+			if (i >= originalSize) break;
+			sub();
+			i++;
+		}
+	}
+}
+let _traceListeners = null;
+/** @internal — called from signal.set() when tracing is active */
+function _notifyTraceListeners(sig, prev, next) {
+	if (!_traceListeners) return;
+	const event = {
+		signal: sig,
+		name: sig.label,
+		prev,
+		next,
+		stack: (/* @__PURE__ */ new Error()).stack ?? "",
+		timestamp: performance.now()
+	};
+	for (const l of _traceListeners) l(event);
+}
+/** Check if any trace listeners are active (fast path for signal.set) */
+function isTracing() {
+	return _traceListeners !== null;
+}
+function _peek() {
+	return this._v;
+}
+function _set(newValue) {
+	if (Object.is(this._v, newValue)) return;
+	const prev = this._v;
+	this._v = newValue;
+	if (isTracing()) _notifyTraceListeners(this, prev, newValue);
+	if (this._d) notifyDirect(this._d);
+	if (this._s) notifySubscribers(this._s);
+}
+function _update(fn) {
+	_set.call(this, fn(this._v));
+}
+function _subscribe(listener) {
+	if (!this._s) this._s = /* @__PURE__ */ new Set();
+	this._s.add(listener);
+	return () => this._s?.delete(listener);
+}
+/**
+* Register a direct updater — lighter than subscribe().
+* Uses a flat array instead of Set. Disposal nulls the slot (no Set.delete overhead).
+* Used by compiler-emitted _bindText/_bindDirect for zero-overhead DOM bindings.
+*/
+function _directFn(updater) {
+	if (!this._d) this._d = [];
+	const arr = this._d;
+	const idx = arr.length;
+	arr.push(updater);
+	return () => {
+		arr[idx] = null;
+	};
+}
+/**
+* Notify direct updaters — flat array iteration, batch-aware.
+* Null slots (from disposed updaters) are skipped.
+*/
+function notifyDirect(updaters) {
+	if (isBatching()) for (let i = 0; i < updaters.length; i++) {
+		const fn = updaters[i];
+		if (fn) enqueuePendingNotification(fn);
+	}
+	else for (let i = 0; i < updaters.length; i++) updaters[i]?.();
+}
+function _debug() {
+	return {
+		name: this.label,
+		value: this._v,
+		subscriberCount: this._s?.size ?? 0
+	};
+}
+/**
+* Create a reactive signal.
+*
+* Only 1 closure is allocated (the read function). State is stored as
+* properties on the function object (_v, _s) and methods (peek, set,
+* update, subscribe) are shared across all signals — not per-signal closures.
+*/
+function signal(initialValue, options) {
+	const read = (() => {
+		trackSubscriber(read);
+		return read._v;
+	});
+	read._v = initialValue;
+	read._s = null;
+	read._d = null;
+	read.peek = _peek;
+	read.set = _set;
+	read.update = _update;
+	read.subscribe = _subscribe;
+	read.direct = _directFn;
+	read.debug = _debug;
+	read.label = options?.name;
+	return read;
+}
+
+//#endregion
+//#region src/useStableValue.ts
+/**
+* Returns a referentially stable version of `value`. The returned reference
+* only changes when the value is no longer deeply equal to the previous one.
+*
+* Pyreon equivalent of the React useStableValue hook — uses a signal
+* internally to hold the stable reference.
+*/
+const useStableValue = (value) => {
+	const ref = signal(value);
+	if (!isEqual(ref.peek(), value)) ref.set(value);
+	return ref.peek();
+};
+
+//#endregion
+//#region src/utils.ts
+const omit = (obj, keys) => {
+	if (obj == null) return {};
+	if (!keys || keys.length === 0) return { ...obj };
+	const result = {};
+	const keysSet = new Set(keys);
+	for (const key in obj) if (Object.hasOwn(obj, key) && !keysSet.has(key)) result[key] = obj[key];
+	return result;
+};
+const pick = (obj, keys) => {
+	if (obj == null) return {};
+	if (!keys || keys.length === 0) return { ...obj };
+	const result = {};
+	for (const key of keys) {
+		const k = key;
+		if (Object.hasOwn(obj, k)) result[k] = obj[k];
+	}
+	return result;
+};
+const PATH_RE = /[^.[\]]+/g;
+const parsePath = (path) => {
+	if (Array.isArray(path)) return path;
+	return path.match(PATH_RE) ?? [];
+};
+const isUnsafeKey = (key) => key === "__proto__" || key === "prototype" || key === "constructor";
+const get = (obj, path, defaultValue) => {
+	const keys = parsePath(path);
+	let result = obj;
+	for (const key of keys) {
+		if (result == null || isUnsafeKey(key)) return defaultValue;
+		result = result[key];
+	}
+	return result === void 0 ? defaultValue : result;
+};
+const set = (obj, path, value) => {
+	const keys = parsePath(path);
+	let current = obj;
+	for (let i = 0; i < keys.length - 1; i++) {
+		const key = keys[i];
+		if (isUnsafeKey(key)) return obj;
+		const nextKey = keys[i + 1];
+		if (isUnsafeKey(nextKey)) return obj;
+		if (current[key] == null) current[key] = /^\d+$/.test(nextKey) ? [] : {};
+		current = current[key];
+	}
+	const lastKey = keys[keys.length - 1];
+	if (lastKey != null && !isUnsafeKey(lastKey)) current[lastKey] = value;
+	return obj;
+};
+const throttle = (fn, wait = 0, options) => {
+	const leading = options?.leading !== false;
+	const trailing = options?.trailing !== false;
+	let lastCallTime;
+	let timeoutId;
+	let lastArgs;
+	const invoke = (args) => {
+		lastCallTime = Date.now();
+		fn(...args);
+	};
+	const startTrailingTimer = (args, delay) => {
+		lastArgs = args;
+		if (timeoutId !== void 0) return;
+		timeoutId = setTimeout(() => {
+			timeoutId = void 0;
+			if (lastArgs) {
+				invoke(lastArgs);
+				lastArgs = void 0;
+			}
+		}, delay);
+	};
+	const throttled = (...args) => {
+		const now = Date.now();
+		const elapsed = lastCallTime === void 0 ? wait : now - lastCallTime;
+		if (elapsed >= wait) if (leading) invoke(args);
+		else {
+			lastCallTime = now;
+			if (trailing) startTrailingTimer(args, wait);
+		}
+		else if (trailing) startTrailingTimer(args, wait - elapsed);
+	};
+	throttled.cancel = () => {
+		if (timeoutId !== void 0) {
+			clearTimeout(timeoutId);
+			timeoutId = void 0;
+		}
+		lastArgs = void 0;
+		lastCallTime = void 0;
+	};
+	return throttled;
+};
+const isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+const merge = (target, ...sources) => {
+	for (const source of sources) {
+		if (source == null) continue;
+		for (const key of Object.keys(source)) {
+			if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+			const targetVal = target[key];
+			const sourceVal = source[key];
+			if (isPlainObject(targetVal) && isPlainObject(sourceVal)) target[key] = merge({ ...targetVal }, sourceVal);
+			else target[key] = sourceVal;
+		}
+	}
+	return target;
+};
+
+//#endregion
+export { HTML_TAGS, HTML_TEXT_TAGS, Provider, compose, config, context, get, hoistNonReactStatics, init, isEmpty, isEqual, merge, omit, pick, render, set, throttle, useStableValue };
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@pyreon/ui-core",
+  "version": "0.0.2",
+  "description": "Core utilities, config, and context for Pyreon UI System",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    "source": "./src/index.ts",
+    "import": "./lib/index.js",
+    "types": "./lib/index.d.ts"
+  },
+  "types": "./lib/index.d.ts",
+  "main": "./lib/index.js",
+  "files": [
+    "lib",
+    "!lib/**/*.map",
+    "!lib/analysis",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">= 18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun run vl_rolldown_build",
+    "lint": "biome check src/",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@pyreon/core": ">=0.3.0",
+    "@pyreon/styler": "^0.0.2"
+  },
+  "devDependencies": {
+    "@vitus-labs/tools-rolldown": "^1.15.0",
+    "@vitus-labs/tools-typescript": "^1.15.0"
+  }
+}