ilha 0.14.3 → 0.14.5

package/dist/types-CUQdA6hR.d.ts

@@ -0,0 +1,43 @@
+import "effect/Scope";
+import { AtomRegistry } from "effect/unstable/reactivity/AtomRegistry";
+import { Effect, Stream } from "effect";
+import { Atom } from "effect/unstable/reactivity";
+//#region src/types.d.ts
+type JsonText = string | number | bigint | boolean | null | undefined;
+/** Runtime prop bag values painted onto elements / passed to components. */
+type PropValue = JsonText | PropBag | StyleObject | EventHandler | AtomHandle<JsonText> | readonly PropValue[];
+type StyleObject = Readonly<Record<string, string | number | null | undefined>>;
+type EventHandler = (event: Event) => void;
+/** Indexed bag — interface so PropValue can recurse without a circular type alias. */
+interface PropBag {
+  readonly [key: string]: PropValue | undefined;
+}
+type View = VNode | JsonText | AtomHandle<unknown> | Stream.Stream<View, unknown, unknown> | GeneratorFn | Component | View[] | Iterable<View>;
+declare const Fragment: unique symbol;
+type Fragment = typeof Fragment;
+type ComponentFn = (props: PropBag) => View | Promise<View | undefined> | undefined;
+/** JSX/tag component with its own props shape (Provider, ErrorBoundary, …). */
+type JsxComponent = (props: never) => View | Promise<View | undefined> | Generator<View, View | undefined, View> | undefined;
+interface VNode {
+  readonly $$ilha: 1;
+  readonly type: string | Fragment | ComponentFn | JsxComponent;
+  readonly props: PropBag;
+  readonly children: View[];
+  readonly key?: string | number;
+}
+type GeneratorFn = () => Generator<Yielded, View | undefined, View>;
+type Yielded = View | Instruction<unknown> | Effect.Effect<unknown, unknown, unknown>;
+interface Instruction<A, E = Error> extends Iterable<Instruction<A, E>, A>, PromiseLike<A> {
+  readonly $$ilhaOp: 1;
+  readonly effect: Effect.Effect<A, E, AtomRegistry>;
+}
+type Component = (() => View | undefined | Promise<View | undefined>) | GeneratorFn;
+interface AtomHandle<A> {
+  readonly $$atom: 1;
+  readonly atom: Atom.Atom<A>;
+  (): A;
+  set: (next: A) => void;
+  update: (f: (current: A) => A) => void;
+}
+//#endregion
+export { Instruction as a, VNode as c, Fragment as i, View as l, Component as n, JsxComponent as o, ComponentFn as r, PropBag as s, AtomHandle as t, Yielded as u };

package/dist/{vnode-15tImQ6O.d.ts → vnode-Bwx8ffNO.d.ts}

@@ -1,24 +1,28 @@
-import { a as VNode, o as View, r as Fragment, t as AtomHandle } from "./types-Cie0Ihl6.js";
+import { c as VNode, i as Fragment, l as View, o as JsxComponent, r as ComponentFn, s as PropBag, t as AtomHandle } from "./types-CUQdA6hR.js";
 //#region src/jsx-types.d.ts
 declare namespace JSX {
   export type Element = View;
-  export type ElementType = string | ((props: Record<string, unknown>) => View | Promise<View | void> | Generator<unknown, View | void, unknown>);
+  export type ElementType = string | ((props: never) => View | Promise<View | undefined> | Generator<View, View | undefined, View> | undefined);
   export interface ElementChildrenAttribute {
-    children: {};
+    children: View;
   }
   /** Scalar attribute value (booleans become presence/absence). */
   type Attr = string | number | boolean | null | undefined;
-  /** Values that can bind through `value` / `checked` / `selected`. */
-  type Bindable<T> = T | AtomHandle<T>;
+  /**
+   * Values that can bind through `value` / `checked` / `selected`.
+   * AtomHandle is invariant in T (via `set`), so constituents of a union T
+   * are listed explicitly — e.g. AtomHandle of string for value={string|number}.
+   */
+  type Bindable<T> = T | AtomHandle<T> | (string extends T ? AtomHandle<string> : never) | (number extends T ? AtomHandle<number> : never) | (boolean extends T ? AtomHandle<boolean> : never);
   type StyleValue = string | Readonly<Record<string, string | number | null | undefined>> | null | undefined;
   type Targeted<Target extends globalThis.EventTarget, E extends globalThis.Event> = Omit<E, "currentTarget"> & {
     readonly currentTarget: Target;
   };
   type Handler<Target extends globalThis.EventTarget, E extends globalThis.Event> = {
-    bivarianceHack(event: Targeted<Target, E>): unknown;
+    bivarianceHack: (event: Targeted<Target, E>) => void;
   }["bivarianceHack"];
   /** Lowercase DOM event props Ilha binds at runtime. */
-  type EventProps<Target extends globalThis.EventTarget> = {
+  interface EventProps<Target extends globalThis.EventTarget> {
     onclick?: Handler<Target, globalThis.MouseEvent>;
     ondblclick?: Handler<Target, globalThis.MouseEvent>;
     onmousedown?: Handler<Target, globalThis.MouseEvent>;
@@ -69,9 +73,9 @@ declare namespace JSX {
     ontransitionend?: Handler<Target, globalThis.TransitionEvent>;
     onload?: Handler<Target, globalThis.Event>;
     onerror?: Handler<Target, globalThis.Event>;
-  };
-  type AriaProps = { [K in `aria-${string}`]?: Attr; };
-  type DataProps = { [K in `data-${string}`]?: Attr; };
+  }
+  type AriaProps = Partial<Record<`aria-${string}`, Attr>>;
+  type DataProps = Partial<Record<`data-${string}`, Attr>>;
   /** Shared HTML attributes. Prefer `class` / `for`; `className` / `htmlFor` also work. */
   type HTMLAttributes<Target extends globalThis.EventTarget = globalThis.HTMLElement> = EventProps<Target> & AriaProps & DataProps & {
     children?: View;
@@ -125,7 +129,7 @@ declare namespace JSX {
   };
   type BodyHTMLAttributes = HTMLAttributes<HTMLBodyElement>;
   type ButtonHTMLAttributes = HTMLAttributes<HTMLButtonElement> & {
-    type?: "button" | "submit" | "reset" | (string & {});
+    type?: "button" | "submit" | "reset" | string;
     value?: Bindable<string | number>;
     name?: Attr;
     disabled?: Attr;
@@ -178,7 +182,7 @@ declare namespace JSX {
     height?: number | string;
     allow?: Attr;
     allowfullscreen?: Attr;
-    loading?: "eager" | "lazy" | (string & {});
+    loading?: "eager" | "lazy" | string;
     referrerpolicy?: Attr;
     sandbox?: Attr;
   };
@@ -189,8 +193,8 @@ declare namespace JSX {
     sizes?: Attr;
     width?: number | string;
     height?: number | string;
-    loading?: "eager" | "lazy" | (string & {});
-    decoding?: "async" | "auto" | "sync" | (string & {});
+    loading?: "eager" | "lazy" | string;
+    decoding?: "async" | "auto" | "sync" | string;
     crossorigin?: Attr;
     referrerpolicy?: Attr;
     usemap?: Attr;
@@ -571,12 +575,11 @@ declare namespace JSX {
       "stop-color"?: Attr;
       "stop-opacity"?: Attr;
     };
-    [tag: string]: any;
   }
   export {};
 }
 //#endregion
 //#region src/vnode.d.ts
-declare function h(type: string | Fragment | ((props: Record<string, unknown>) => unknown), props: Record<string, unknown> | null | undefined, ...rest: View[]): VNode;
+declare const h: (type: string | Fragment | ComponentFn | JsxComponent, props: PropBag | null | undefined, ...rest: View[]) => VNode;
 //#endregion
 export { JSX as n, h as t };

package/dist/vnode-DEMDQ0eA.js

@@ -0,0 +1,91 @@
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+
+//#region src/errors.ts
+const asFailure = (e) => {
+	if (Result.isResult(e) && Result.isFailure(e)) {
+		const v = Option.getOrUndefined(Result.getFailure(e));
+		return Result.fail(v instanceof Error ? v : new Error(String(v)));
+	}
+	return Result.fail(e instanceof Error ? e : new Error(String(e)));
+};
+/** Normalize any thrown failure into an `Error` instance. */
+const toError = (e) => asFailure(e).pipe(Result.match({
+	onFailure: (err) => err,
+	onSuccess: () => /* @__PURE__ */ new Error("error")
+}));
+const failureMessage = (e) => toError(e).message;
+
+//#endregion
+//#region src/shared.ts
+const KEY_ATTR = "data-ilha-key";
+const SLOT_ATTR = "data-ilha-slot";
+const ISLAND = Symbol.for("ilha.island");
+const ISLAND_MOUNT_INTERNAL = Symbol.for("ilha.islandMountInternal");
+const ISLAND_SLOT_TAG = Symbol.for("ilha.islandSlotTag");
+const objectTag = (value) => Object.prototype.toString.call(value);
+const isBoolean = (value) => value === true || value === false;
+const isString = (value) => objectTag(value) === "[object String]";
+const isNumber = (value) => objectTag(value) === "[object Number]";
+const isBigInt = (value) => objectTag(value) === "[object BigInt]";
+const isFunction = (value) => {
+	const tag = objectTag(value);
+	return tag === "[object Function]" || tag === "[object AsyncFunction]" || tag === "[object GeneratorFunction]";
+};
+const isObject = (value) => value !== null && objectTag(value) === "[object Object]";
+const skip = (x) => x === null || x === void 0 || isBoolean(x);
+const KEEP = Symbol("ilha.keep");
+const unwrap = (value, keep) => {
+	if (AsyncResult.isAsyncResult(value)) {
+		if (AsyncResult.isWaiting(value) && keep !== void 0) return KEEP;
+		if (AsyncResult.isFailure(value) && !AsyncResult.isWaiting(value)) return String(AsyncResult.error(value) ?? "error");
+		const v = AsyncResult.value(value);
+		if (v._tag === "Some") return v.value;
+		return "";
+	}
+	return value;
+};
+const errorView = (e) => ({
+	$$ilha: 1,
+	children: [failureMessage(e)],
+	props: { "data-ilha-error": "" },
+	type: "pre"
+});
+
+//#endregion
+//#region src/types.ts
+const Fragment = Symbol("ilha.Fragment");
+
+//#endregion
+//#region src/vnode.ts
+const flatten = (xs) => {
+	const out = [];
+	for (const x of xs) if (Array.isArray(x)) out.push(...flatten(x));
+	else out.push(x);
+	return out;
+};
+const h = (type, props, ...rest) => {
+	const p = { ...props };
+	const fromProps = p.children;
+	const { key: rawKey, ...restProps } = p;
+	return {
+		$$ilha: 1,
+		children: flatten([...fromProps === void 0 ? [] : [fromProps], ...rest]),
+		key: rawKey,
+		props: restProps,
+		type
+	};
+};
+const isVNode = (x) => {
+	if (!isObject(x)) return false;
+	return x.$$ilha === 1;
+};
+const isSetupFn = (x) => {
+	if (!isFunction(x)) return false;
+	const n = x.constructor?.name;
+	return n === "GeneratorFunction" || n === "AsyncFunction";
+};
+
+//#endregion
+export { skip as _, ISLAND as a, failureMessage as b, KEEP as c, errorView as d, isBigInt as f, isString as g, isObject as h, Fragment as i, KEY_ATTR as l, isNumber as m, isSetupFn as n, ISLAND_MOUNT_INTERNAL as o, isFunction as p, isVNode as r, ISLAND_SLOT_TAG as s, h as t, SLOT_ATTR as u, unwrap as v, toError as x, asFailure as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilha",
-  "version": "0.14.3",
+  "version": "0.14.5",
   "description": "Generator-first island UI on Effect",
   "keywords": [
     "effect",