creo 0.1.0 → 0.2.1

package/dist/internal/internal_view.d.ts

@@ -1,38 +1,29 @@
 import type { Key } from "../functional/key";
-import type { Children, Slot, ViewBody, ViewFn } from "../public/view";
-import type { Engine } from "./engine";
-import { IndexedList } from "../structures/indexed_list";
+import type { SlotContent, ViewBody, ViewFn } from "../public/view";
 import type { Maybe } from "../functional/maybe";
 import type { Wildcard } from "./wildcard";
-export type PendingView<Props = Wildcard, Api = Wildcard> = {
+export type BitFlags = number;
+export declare const F_PENDING = 1;
+export declare const F_DIRTY: number;
+export declare const F_MOVED: number;
+export declare const F_PRIMITIVE: number;
+export declare const F_TEXT_CONTENT: number;
+export declare const F_DISPOSED: number;
+export type ViewRecord<Props = Wildcard, Api = Wildcard, RenderRef = Wildcard> = {
     viewFn: ViewFn<Props, Api>;
-    props: Props;
-    slot: Maybe<Slot>;
     userKey: Maybe<Key>;
-};
-export declare class View<Props = Wildcard, Api = Wildcard> implements Disposable {
-    #private;
-    viewFn: ViewFn<Props, Api>;
-    engine: Engine;
-    parent: Maybe<View>;
-    userKey: Maybe<Key>;
-    renderRef: unknown;
     props: Props;
-    slotChildren: Children;
-    body: ViewBody<Props, Api>;
-    virtualDom: Maybe<IndexedList<View>>;
-    keyToIndex: Maybe<Map<Key, number>>;
-    dirty: boolean;
-    moved: boolean;
-    quickRerender: boolean;
-    constructor(viewFn: ViewFn<Props, Api>, initialProps: Props, slot: Maybe<Slot>, engine: Engine, parent: Maybe<View>, userKey: Maybe<Key>);
-    markDirty: () => void;
-    markMove(): void;
-    shouldUpdate(nextProps: Props): boolean;
-    onMount: () => void;
-    onUpdateBefore(): void;
-    onUpdateAfter: () => void;
-    nextProps(nextProps: Props, nextSlot: Maybe<Slot>): void;
-    reconsile(): void;
-    [Symbol.dispose](): void;
-}
+    slot: Maybe<SlotContent>;
+    body: Maybe<ViewBody<Props, Api>>;
+    sc: Maybe<ViewRecord[]>;
+    renderRef: Maybe<RenderRef>;
+    flags: BitFlags;
+    children: Maybe<ViewRecord[]>;
+    keyToView: Maybe<Map<Key, ViewRecord>>;
+    unsubscribe: Maybe<(() => void)[]>;
+    parent: Maybe<ViewRecord>;
+    /** The primitive whose .children contains the live sc items after reconcile. */
+    scHost: Maybe<ViewRecord>;
+};
+/** Structural change: viewFn, key, or count differs. Does NOT check props. */
+export declare function hasScStructuralChange(prev: Maybe<ViewRecord[]>, next: Maybe<ViewRecord[]>): boolean;

package/dist/internal/orchestrator.d.ts

@@ -9,7 +9,7 @@ import type { Engine } from "../internal/engine";
  */
 declare class Orchestrator {
     #private;
-    setCurrentEngine(engine: Engine): void;
+    setCurrentEngine(engine: Maybe<Engine>): void;
     currentEngine(): Maybe<Engine>;
 }
 export declare const orchestrator: Orchestrator;

package/dist/public/primitives/primitives.d.ts

@@ -1,5 +1,5 @@
 import { type EventHandlerProps } from "../primitive";
-import { type PublicView } from "../view";
+import { type PublicView, type ViewFn } from "../view";
 export type BaseEventData = {
     stopPropagation: () => void;
     preventDefault: () => void;
@@ -45,7 +45,8 @@ export type HtmlAttrs = {
     [attr: string]: unknown;
 };
 export declare function html<Attrs extends HtmlAttrs = HtmlAttrs, Events = ContainerEvents>(tag: string): PublicView<Attrs & EventHandlerProps<Events>, void>;
-export declare const text: PublicView<any, void>;
+export declare const textViewFn: ViewFn<string | number, void>;
+export declare function text(content: string | number): void;
 export declare const div: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
 export declare const span: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;
 export declare const section: PublicView<HtmlAttrs & EventHandlerProps<ContainerEvents>, void>;

package/dist/public/view.d.ts

@@ -1,26 +1,24 @@
 import type { Key } from "../functional/key";
-import type { Maybe } from "../functional/maybe";
 import type { Use } from "./state";
-import type { PendingView } from "../internal/internal_view";
 import type { $primitive } from "./primitive";
 export type ViewBody<Props, Api> = Api extends void ? {
     render: () => void;
     onMount?: () => void;
     shouldUpdate?: (nextProps: Props) => boolean;
     onUpdateBefore?: () => void;
-    onUpdateafter?: () => void;
+    onUpdateAfter?: () => void;
 } : {
     render: () => void;
     onMount?: () => void;
     shouldUpdate?: (nextProps: Props) => boolean;
     onUpdateBefore?: () => void;
-    onUpdateafter?: () => void;
+    onUpdateAfter?: () => void;
     api: Api;
 };
 /** Slot callback — passed by the caller at the call site. */
 export type Slot = () => void;
-/** Children — pre-collected PendingViews available inside the view. */
-export type Children = Maybe<PendingView[]>;
+/** What callers may pass as a slot: a callback or a plain string (rendered as text). */
+export type SlotContent = Slot | string;
 export type ViewFn<Props, Api> = {
     (ctx: {
         props: () => Props;
@@ -29,9 +27,14 @@ export type ViewFn<Props, Api> = {
     }): ViewBody<Props, Api>;
     [$primitive]?: string;
 };
-export declare function view<Props = void, Api = void>(body: ViewFn<Props, Api>): (props: Props extends void ? {
+/** Resolves to the caller-facing props type. Allows `void` when Props is void or all-optional. */
+type ViewProps<Props> = Props extends void ? {
     key?: Key;
-} | void : Props & {
+} | void : {} extends Props ? (Props & {
     key?: Key;
-}, slot?: Slot) => void;
+}) | void : Props & {
+    key?: Key;
+};
+export declare function view<Props = void, Api = void>(body: ViewFn<Props, Api>): (props: ViewProps<Props>, slot?: SlotContent) => void;
 export type PublicView<Props, Api> = ReturnType<typeof view<Props, Api>>;
+export {};

package/dist/render/html_render.d.ts

@@ -1,35 +1,22 @@
-import type { View } from "../internal/internal_view";
+import type { ViewRecord } from "../internal/internal_view";
 import type { IRender } from "./render_interface";
+import type { Engine } from "../internal/engine";
 export declare class HtmlRender implements IRender<HTMLElement | Text> {
+    #private;
     private container;
+    engine: Engine;
     constructor(container: HTMLElement);
-    render(view: View): void;
-    unmount(view: View): void;
-    private buildDom;
-    private isEventProp;
-    private eventPropToCreoName;
+    render(view: ViewRecord): void;
+    unmount(view: ViewRecord): void;
+    private findParentDom;
+    private findInsertionPoint;
     private setAttributes;
     private diffAttributes;
     private bindEvent;
     private unbindEvent;
-    private mapEventData;
     private setAttribute;
     private removeAttribute;
-    /**
-     * Compute where a view's DOM node should be placed in its parent.
-     *
-     * Fast paths (O(1)):
-     *  - Last child → endComment (composite) or null/appendChild (primitive)
-     *  - Previous sibling rendered → nextSibling of prev's last DOM node
-     *
-     * Slow path (O(k)): walk backward through unrendered siblings.
-     *
-     * Composite parents always return endComment as fallback (never null),
-     * so insertBefore(node, result) is safe for all parent types.
-     */
-    private fastInsertionPoint;
-    private getParentDomNode;
-    private moveDomNodes;
     private getFirstDomNode;
+    private moveDomNodes;
     private removeDomNodes;
 }

package/dist/render/json_render.d.ts

@@ -1,6 +1,7 @@
-import type { View } from "../internal/internal_view";
+import type { ViewRecord } from "../internal/internal_view";
 import type { IRender } from "./render_interface";
 import type { Maybe } from "../functional/maybe";
+import type { Engine } from "../internal/engine";
 export type JsonNode = {
     type: string;
     props: Record<string, unknown>;
@@ -10,8 +11,9 @@ export type JsonNode = {
 export declare class JsonRender implements IRender<JsonNode> {
     /** The root JSON node after mount. */
     root: Maybe<JsonNode>;
-    render(view: View): void;
-    unmount(view: View): void;
-    private getNextSibling;
+    engine: Engine;
+    constructor();
+    render(view: ViewRecord): void;
+    unmount(view: ViewRecord): void;
     private buildNode;
 }

package/dist/render/render_interface.d.ts

@@ -1,7 +1,9 @@
-import type { View } from "../internal/internal_view";
+import type { ViewRecord } from "../internal/internal_view";
+import type { Engine } from "../internal/engine";
 export interface IRender<Output> {
+    engine: Engine;
     /** Create output if view is new (no renderRef), or update if existing. */
-    render(view: View): void;
-    /** Remove a view's output artifacts. Called from View[Symbol.dispose]. */
-    unmount(view: View): void;
+    render(view: ViewRecord): void;
+    /** Remove a view's output artifacts. */
+    unmount(view: ViewRecord): void;
 }

package/dist/render/string_render.d.ts

@@ -1,17 +1,22 @@
-import type { View } from "../internal/internal_view";
+import type { ViewRecord } from "../internal/internal_view";
 import type { IRender } from "./render_interface";
+import type { Engine } from "../internal/engine";
 /**
- * Stateless string renderer — pull-based.
- * mount/unmount/update are no-ops. Call renderToString() to
+ * HtmlStringRender — pull-based string renderer.
+ * render/unmount are no-ops. Call renderToString() to
  * get the current HTML string from the VDOM.
+ *
+ * Output matches HtmlRender's DOM serialization (innerHTML).
  */
-export declare class StringRender implements IRender<string> {
-    private rootView;
-    render(view: View): void;
-    unmount(_view: View): void;
-    /** Build and return the current HTML string from the VDOM. */
+export declare class HtmlStringRender implements IRender<string> {
+    private root;
+    engine: Engine;
+    render(view: ViewRecord): void;
+    unmount(_view: ViewRecord): void;
     renderToString(): string;
     private buildString;
-    private buildVoidTag;
+    private buildAttrs;
     private buildChildren;
 }
+/** @deprecated Use HtmlStringRender instead */
+export declare const StringRender: typeof HtmlStringRender;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "creo",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
   "files": [