tosijs 1.0.10 → 1.1.0

package/dist/path-listener.d.ts

@@ -1,4 +1,4 @@
-import { PathTestFunction, ObserverCallbackFunction } from './xin-types';
+import { PathTestFunction, ObserverCallbackFunction, XinTouchableType } from './xin-types';
 export declare const observerShouldBeRemoved: unique symbol;
 export declare const listeners: Listener[];
 export declare class Listener {
@@ -8,6 +8,6 @@ export declare class Listener {
     constructor(test: string | RegExp | PathTestFunction, callback: string | ObserverCallbackFunction);
 }
 export declare const updates: () => Promise<void>;
-export declare const touch: (touchable: any) => void;
+export declare const touch: (touchable: XinTouchableType) => void;
 export declare const observe: (test: string | RegExp | PathTestFunction, callback: ObserverCallbackFunction) => Listener;
 export declare const unobserve: (listener: Listener) => void;

package/dist/registry.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Central registry for xin state.
+ * Extracted to break circular dependency between xin.ts and bind.ts.
+ */
+import { XinObject, XinProxy, XinBinding } from './xin-types';
+export declare const registry: XinObject;
+export declare const setXinProxy: (xin: XinProxy<XinObject>) => void;
+export declare const getXinProxy: () => XinProxy<XinObject>;
+type BindFunc = (element: Element, path: string, binding: XinBinding, options?: XinObject) => void;
+type OnFunc = any;
+export declare const setBindFunctions: (bind: BindFunc, on: OnFunc) => void;
+export declare const getBind: () => BindFunc;
+export declare const getOn: () => OnFunc;
+export {};

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "1.0.10";
+export declare const version = "1.1.0";

package/dist/xin-types.d.ts

@@ -25,11 +25,54 @@ type ListTemplateBuilder<U = any> = (elements: ElementsProxy, item: U) => HTMLEl
 type ListBinding = [ElementProps, HTMLTemplateElement];
 export interface BoxedArrayProps<U = any> {
     tosiListBinding: (templateBuilder: ListTemplateBuilder<U>, options?: ListBindingOptions) => ListBinding;
+    listBinding: (templateBuilder: ListTemplateBuilder<U>, options?: ListBindingOptions) => ListBinding;
+}
+/**
+ * BoxedScalar represents a boxed primitive value (string, number, boolean, null, undefined).
+ * It provides a clean API for accessing the value and path, and catches the common
+ * comparison trap where users write `proxy.x === 3` instead of `proxy.x.value === 3`.
+ *
+ * Note: Direct assignment like `proxy.x = 3` is a TypeScript type error due to
+ * fundamental limitations in TypeScript's mapped types (no asymmetric get/set).
+ * Use `proxy.x.value = 3` instead.
+ */
+export interface BoxedScalar<T> {
+    value: T;
+    path: string;
+    observe: (callback: ObserverCallbackFunction) => VoidFunction;
+    bind: <E extends Element = Element>(element: E, binding: XinBinding<E>, options?: XinObject) => void;
+    on: (element: HTMLElement, eventType: keyof HTMLElementEventMap) => VoidFunction;
+    binding: (binding: XinBinding) => {
+        bind: {
+            value: string;
+            binding: XinBinding;
+        };
+    };
+    listBinding: (templateBuilder: ListTemplateBuilder<T>, options?: ListBindingOptions) => ListBinding;
+    valueOf: () => T;
+    toString: () => string;
+    toJSON: () => T;
+    xinValue: T;
+    xinPath: string;
+    tosiValue: T;
+    tosiPath: string;
+    xinObserve: (callback: ObserverCallbackFunction) => VoidFunction;
+    tosiObserve: (callback: ObserverCallbackFunction) => VoidFunction;
+    xinBind: <E extends Element = Element>(element: E, binding: XinBinding<E>, options?: XinObject) => void;
+    tosiBind: <E extends Element = Element>(element: E, binding: XinBinding<E>, options?: XinObject) => void;
+    xinOn: (element: HTMLElement, eventType: keyof HTMLElementEventMap) => VoidFunction;
+    tosiOn: (element: HTMLElement, eventType: keyof HTMLElementEventMap) => VoidFunction;
+    tosiBinding: (binding: XinBinding) => {
+        bind: {
+            value: string;
+            binding: XinBinding;
+        };
+    };
 }
 export type BoxedProxy<T = any> = T extends Array<infer U> ? Array<BoxedProxy<U>> & XinProps<T> & BoxedArrayProps<U> : T extends Function ? T & XinProps<Function> : T extends object ? {
     [K in keyof T]: BoxedProxy<T[K]>;
-} & XinProps<T> : T extends string ? String & XinProps<string> : T extends number ? Number & XinProps<number> : T extends boolean ? Boolean & XinProps<boolean> : T extends undefined | null ? {} & XinProps<T> : T;
-export type Unboxed<T = any> = T extends String ? string : T extends Number ? number : T extends Boolean ? boolean : T;
+} & XinProps<T> : T extends string ? BoxedScalar<string> : T extends number ? BoxedScalar<number> : T extends boolean ? BoxedScalar<boolean> : T extends undefined | null ? BoxedScalar<T> : T;
+export type Unboxed<T = any> = T extends BoxedScalar<infer U> ? U : T extends String ? string : T extends Number ? number : T extends Boolean ? boolean : T;
 export type XinProxy<T = any> = T extends Array<infer U> ? Array<XinProxy<U>> : T extends Function ? T : T extends object ? {
     [K in keyof T]: T[K] extends object ? XinProxy<T[K]> : T[K];
 } : T;
@@ -120,6 +163,8 @@ export interface ListBindingOptions {
         width?: number;
         visibleColumns?: number;
         rowChunkSize?: number;
+        /** Use 'window' to virtualize based on window scroll position instead of element scroll */
+        scrollContainer?: 'window' | 'element';
     };
     hiddenProp?: symbol | string;
     visibleProp?: symbol | string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tosijs",
-  "version": "1.0.10",
+  "version": "1.1.0",
   "description": "path-based state management for web apps",
   "source": "src/index.ts",
   "types": "dist/index.d.ts",