@tachui/core 0.7.0-alpha1

package/dist/state/index.d.ts

@@ -0,0 +1,108 @@
+/**
+ * SwiftUI-Style State Management
+ *
+ * This module provides SwiftUI-compatible property wrappers for state management:
+ * - @State: Local component state with automatic reactivity
+ * - @Binding: Two-way data binding between parent and child components
+ * - @ObservedObject: Observation of external objects that implement ObservableObject
+ * - @EnvironmentObject: Dependency injection through environment context
+ */
+import { createEnvironmentKey, createObservableEnvironmentObject, EnvironmentObject, provideEnvironmentObject } from './environment';
+import { makeObservable, observable } from './observed-object';
+import { createBinding } from './state';
+export { BindingImpl, BindingUtils, createBinding as createEnhancedBinding, isBinding as isEnhancedBinding, } from './binding';
+export { CommonEnvironmentKeys, createEnvironmentKey, createObservableEnvironmentObject, EnvironmentObject, isEnvironmentObject, provideEnvironmentObject, } from './environment';
+export { createObservableStore, isObservableObject, isObservedObject, makeObservable, ObservableObjectBase, ObservedObjectWrapper as ObservedObject, observable, } from './observed-object';
+export { createBinding, createStateBinding, isBinding, isState, State, unwrapValue, } from './state';
+export type { Binding, BindingFactory, BindingOptions, BindingValue, ComputedProperty, EnvironmentKey, EnvironmentObject as IEnvironmentObject, EnvironmentObjectFactory, EnvironmentObjectOptions, EnvironmentObjectProvider, ObservableObject, ObservableObjectOptions, ObservedObject as IObservedObject, ObservedObjectFactory, PropertyWrapper, PropertyWrapperMetadata, PropertyWrapperRegistry, State as IState, StateBinding, StateFactory, StateManager, StateWrapperOptions, } from './types';
+export declare const createEnvironmentObjectProvider: typeof provideEnvironmentObject;
+export declare function useEnvironmentObject(key: any): EnvironmentObject<unknown>;
+/**
+ * Re-export commonly used reactive primitives from the reactive system
+ */
+export { createComputed, createEffect, createMemo, createSignal } from '../reactive';
+export { createStateManager, getAllStateManagers, getStateManager, getStateManagerDebugInfo, initializeStateDebugging, registerStateManager, StateManagerImpl, unregisterStateManager, } from './state-manager';
+/**
+ * Utility functions for working with property wrappers
+ */
+export declare const StateUtils: {
+    /**
+     * Check if a value is any kind of property wrapper
+     */
+    isPropertyWrapper(value: any): value is {
+        wrappedValue: any;
+        projectedValue: any;
+    };
+    /**
+     * Extract the wrapped value from any property wrapper
+     */
+    unwrap<T>(wrapper: any): T;
+    /**
+     * Create a debug snapshot of all property wrappers in a component
+     */
+    createDebugSnapshot(componentId: string): any;
+};
+/**
+ * Default export with all property wrappers
+ */
+declare const _default: {
+    State: import("./types").StateFactory;
+    EnvironmentObject: typeof EnvironmentObject;
+    createStateBinding: typeof createBinding;
+    createBinding: typeof createBinding;
+    makeObservable: typeof makeObservable;
+    observable: typeof observable;
+    createEnvironmentKey: typeof createEnvironmentKey;
+    provideEnvironmentObject: typeof provideEnvironmentObject;
+    createObservableEnvironmentObject: typeof createObservableEnvironmentObject;
+    CommonEnvironmentKeys: {
+        Theme: import("../runtime/component-context").EnvironmentKey<{
+            mode: "light" | "dark";
+            primaryColor: string;
+            secondaryColor: string;
+        }>;
+        Localization: import("../runtime/component-context").EnvironmentKey<{
+            locale: string;
+            t: (key: string, params?: Record<string, any>) => string;
+        }>;
+        Navigation: import("../runtime/component-context").EnvironmentKey<{
+            navigate: (path: string) => void;
+            goBack: () => void;
+            getCurrentRoute: () => string;
+        }>;
+        Config: import("../runtime/component-context").EnvironmentKey<{
+            apiUrl: string;
+            version: string;
+            environment: "development" | "staging" | "production";
+        }>;
+        Auth: import("../runtime/component-context").EnvironmentKey<{
+            isAuthenticated: boolean;
+            user?: {
+                id: string;
+                name: string;
+                email: string;
+            };
+            login: (credentials: any) => Promise<void>;
+            logout: () => Promise<void>;
+        }>;
+    };
+    StateUtils: {
+        /**
+         * Check if a value is any kind of property wrapper
+         */
+        isPropertyWrapper(value: any): value is {
+            wrappedValue: any;
+            projectedValue: any;
+        };
+        /**
+         * Extract the wrapped value from any property wrapper
+         */
+        unwrap<T>(wrapper: any): T;
+        /**
+         * Create a debug snapshot of all property wrappers in a component
+         */
+        createDebugSnapshot(componentId: string): any;
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/state/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/state/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAEL,oBAAoB,EACpB,iCAAiC,EACjC,iBAAiB,EACjB,wBAAwB,EACzB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAE9D,OAAO,EAAE,aAAa,EAA6B,MAAM,SAAS,CAAA;AAGlE,OAAO,EACL,WAAW,EACX,YAAY,EACZ,aAAa,IAAI,qBAAqB,EACtC,SAAS,IAAI,iBAAiB,GAC/B,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,iCAAiC,EACjC,iBAAiB,EACjB,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,eAAe,CAAA;AAGtB,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,qBAAqB,IAAI,cAAc,EACvC,UAAU,GACX,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,SAAS,EACT,OAAO,EACP,KAAK,EACL,WAAW,GACZ,MAAM,SAAS,CAAA;AAEhB,YAAY,EACV,OAAO,EACP,cAAc,EACd,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,iBAAiB,IAAI,kBAAkB,EACvC,wBAAwB,EACxB,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,EAChB,uBAAuB,EACvB,cAAc,IAAI,eAAe,EACjC,qBAAqB,EACrB,eAAe,EACf,uBAAuB,EACvB,uBAAuB,EACvB,KAAK,IAAI,MAAM,EACf,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,mBAAmB,GACpB,MAAM,SAAS,CAAA;AAGhB,eAAO,MAAM,+BAA+B,iCAA2B,CAAA;AACvE,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,GAAG,8BAG5C;AAED;;GAEG;AACH,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAEpF,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,wBAAwB,EACxB,wBAAwB,EACxB,oBAAoB,EACpB,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,iBAAiB,CAAA;AAExB;;GAEG;AACH,eAAO,MAAM,UAAU;IACrB;;OAEG;6BACsB,GAAG,GAAG,KAAK,IAAI;QAAE,YAAY,EAAE,GAAG,CAAC;QAAC,cAAc,EAAE,GAAG,CAAA;KAAE;IAMlF;;OAEG;WACI,CAAC,WAAW,GAAG,GAAG,CAAC;IAO1B;;OAEG;qCAC8B,MAAM,GAAG,GAAG;CA6B9C,CAAA;AAED;;GAEG;;;;;;;;;;;;;;;;;;;mCAcuwG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;QArEzwG;;WAEG;iCACsB,GAAG,GAAG,KAAK,IAAI;YAAE,YAAY,EAAE,GAAG,CAAC;YAAC,cAAc,EAAE,GAAG,CAAA;SAAE;QAMlF;;WAEG;eACI,CAAC,WAAW,GAAG,GAAG,CAAC;QAO1B;;WAEG;yCAC8B,MAAM,GAAG,GAAG;;;AAkC/C,wBAYC"}

package/dist/state/index.js

@@ -0,0 +1,63 @@
+import { provideEnvironmentObject as o, EnvironmentObject as i } from "./environment.js";
+import { CommonEnvironmentKeys as O, createObservableEnvironmentObject as f, isEnvironmentObject as v } from "./environment.js";
+import { createSignal as S } from "../reactive/signal.js";
+import "../reactive/cleanup.js";
+import "../reactive/unified-scheduler.js";
+import "../reactive/scheduler.js";
+import "../reactive/theme.js";
+import { StateManagerImpl as M, createStateManager as w, getAllStateManagers as _, getStateManager as h, getStateManagerDebugInfo as x, initializeStateDebugging as y, registerStateManager as C, unregisterStateManager as D } from "./state-manager.js";
+const g = o;
+function p(e) {
+  return console.warn("useEnvironmentObject is deprecated, use EnvironmentObject instead"), i(e);
+}
+const m = {
+  /**
+   * Check if a value is any kind of property wrapper
+   */
+  isPropertyWrapper(e) {
+    return e && typeof e == "object" && "wrappedValue" in e && "projectedValue" in e;
+  },
+  /**
+   * Extract the wrapped value from any property wrapper
+   */
+  unwrap(e) {
+    return this.isPropertyWrapper(e) ? e.wrappedValue : e;
+  },
+  /**
+   * Create a debug snapshot of all property wrappers in a component
+   */
+  createDebugSnapshot(e) {
+    if (typeof window < "u") {
+      const r = window.__TACHUI_DEBUG__;
+      if (r)
+        return {
+          states: r.states ? Object.keys(r.states).filter((t) => t.startsWith(e)).reduce((t, n) => (t[n] = r.states[n].getValue(), t), {}) : {},
+          observedObjects: r.observedObjects ? Object.keys(r.observedObjects).filter((t) => t.startsWith(e)).reduce((t, n) => (t[n] = {
+            notificationCount: r.observedObjects[n].getNotificationCount(),
+            object: r.observedObjects[n].getObject()
+          }, t), {}) : {}
+        };
+    }
+    return null;
+  }
+};
+export {
+  O as CommonEnvironmentKeys,
+  i as EnvironmentObject,
+  M as StateManagerImpl,
+  m as StateUtils,
+  g as createEnvironmentObjectProvider,
+  f as createObservableEnvironmentObject,
+  S as createSignal,
+  w as createStateManager,
+  _ as getAllStateManagers,
+  h as getStateManager,
+  x as getStateManagerDebugInfo,
+  y as initializeStateDebugging,
+  v as isEnvironmentObject,
+  o as provideEnvironmentObject,
+  C as registerStateManager,
+  D as unregisterStateManager,
+  p as useEnvironmentObject
+};
+//# sourceMappingURL=index.js.map

package/dist/state/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../src/state/index.ts"],"sourcesContent":["/**\n * SwiftUI-Style State Management\n *\n * This module provides SwiftUI-compatible property wrappers for state management:\n * - @State: Local component state with automatic reactivity\n * - @Binding: Two-way data binding between parent and child components\n * - @ObservedObject: Observation of external objects that implement ObservableObject\n * - @EnvironmentObject: Dependency injection through environment context\n */\n\nimport {\n  CommonEnvironmentKeys,\n  createEnvironmentKey,\n  createObservableEnvironmentObject,\n  EnvironmentObject,\n  provideEnvironmentObject,\n} from './environment'\nimport { makeObservable, observable } from './observed-object'\n// Import actual implementations\nimport { createBinding, createStateBinding, State } from './state'\n\n// Enhanced @Binding property wrapper\nexport {\n  BindingImpl,\n  BindingUtils,\n  createBinding as createEnhancedBinding,\n  isBinding as isEnhancedBinding,\n} from './binding'\n// @EnvironmentObject property wrapper\nexport {\n  CommonEnvironmentKeys,\n  createEnvironmentKey,\n  createObservableEnvironmentObject,\n  EnvironmentObject,\n  isEnvironmentObject,\n  provideEnvironmentObject,\n} from './environment'\n\n// @ObservedObject property wrapper\nexport {\n  createObservableStore,\n  isObservableObject,\n  isObservedObject,\n  makeObservable,\n  ObservableObjectBase,\n  ObservedObjectWrapper as ObservedObject,\n  observable,\n} from './observed-object'\n// @State property wrapper\nexport {\n  createBinding,\n  createStateBinding,\n  isBinding,\n  isState,\n  State,\n  unwrapValue,\n} from './state'\n// Core types\nexport type {\n  Binding,\n  BindingFactory,\n  BindingOptions,\n  BindingValue,\n  ComputedProperty,\n  EnvironmentKey,\n  EnvironmentObject as IEnvironmentObject,\n  EnvironmentObjectFactory,\n  EnvironmentObjectOptions,\n  EnvironmentObjectProvider,\n  ObservableObject,\n  ObservableObjectOptions,\n  ObservedObject as IObservedObject,\n  ObservedObjectFactory,\n  PropertyWrapper,\n  PropertyWrapperMetadata,\n  PropertyWrapperRegistry,\n  State as IState,\n  StateBinding,\n  StateFactory,\n  StateManager,\n  StateWrapperOptions,\n} from './types'\n\n// Legacy compatibility exports (for failing tests)\nexport const createEnvironmentObjectProvider = provideEnvironmentObject\nexport function useEnvironmentObject(key: any) {\n  console.warn('useEnvironmentObject is deprecated, use EnvironmentObject instead')\n  return EnvironmentObject(key)\n}\n\n/**\n * Re-export commonly used reactive primitives from the reactive system\n */\nexport { createComputed, createEffect, createMemo, createSignal } from '../reactive'\n// State manager\nexport {\n  createStateManager,\n  getAllStateManagers,\n  getStateManager,\n  getStateManagerDebugInfo,\n  initializeStateDebugging,\n  registerStateManager,\n  StateManagerImpl,\n  unregisterStateManager,\n} from './state-manager'\n\n/**\n * Utility functions for working with property wrappers\n */\nexport const StateUtils = {\n  /**\n   * Check if a value is any kind of property wrapper\n   */\n  isPropertyWrapper(value: any): value is { wrappedValue: any; projectedValue: any } {\n    return (\n      value && typeof value === 'object' && 'wrappedValue' in value && 'projectedValue' in value\n    )\n  },\n\n  /**\n   * Extract the wrapped value from any property wrapper\n   */\n  unwrap<T>(wrapper: any): T {\n    if (this.isPropertyWrapper(wrapper)) {\n      return wrapper.wrappedValue\n    }\n    return wrapper\n  },\n\n  /**\n   * Create a debug snapshot of all property wrappers in a component\n   */\n  createDebugSnapshot(componentId: string): any {\n    if (typeof window !== 'undefined') {\n      const debug = (window as any).__TACHUI_DEBUG__\n      if (debug) {\n        return {\n          states: debug.states\n            ? Object.keys(debug.states)\n                .filter((key: string) => key.startsWith(componentId))\n                .reduce((acc: any, key: string) => {\n                  acc[key] = debug.states[key].getValue()\n                  return acc\n                }, {})\n            : {},\n          observedObjects: debug.observedObjects\n            ? Object.keys(debug.observedObjects)\n                .filter((key: string) => key.startsWith(componentId))\n                .reduce((acc: any, key: string) => {\n                  acc[key] = {\n                    notificationCount: debug.observedObjects[key].getNotificationCount(),\n                    object: debug.observedObjects[key].getObject(),\n                  }\n                  return acc\n                }, {})\n            : {},\n        }\n      }\n    }\n    return null\n  },\n}\n\n/**\n * Default export with all property wrappers\n */\nexport default {\n  State,\n  EnvironmentObject,\n  createStateBinding,\n  createBinding,\n  makeObservable,\n  observable,\n  createEnvironmentKey,\n  provideEnvironmentObject,\n  createObservableEnvironmentObject,\n  CommonEnvironmentKeys,\n  StateUtils,\n}\n"],"names":["createEnvironmentObjectProvider","provideEnvironmentObject","useEnvironmentObject","key","EnvironmentObject","StateUtils","value","wrapper","componentId","debug","acc"],"mappings":";;;;;;;;AAoFO,MAAMA,IAAkCC;AACxC,SAASC,EAAqBC,GAAU;AAC7C,iBAAQ,KAAK,mEAAmE,GACzEC,EAAkBD,CAAG;AAC9B;AAqBO,MAAME,IAAa;AAAA;AAAA;AAAA;AAAA,EAIxB,kBAAkBC,GAAiE;AACjF,WACEA,KAAS,OAAOA,KAAU,YAAY,kBAAkBA,KAAS,oBAAoBA;AAAA,EAEzF;AAAA;AAAA;AAAA;AAAA,EAKA,OAAUC,GAAiB;AACzB,WAAI,KAAK,kBAAkBA,CAAO,IACzBA,EAAQ,eAEVA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,oBAAoBC,GAA0B;AAC5C,QAAI,OAAO,SAAW,KAAa;AACjC,YAAMC,IAAS,OAAe;AAC9B,UAAIA;AACF,eAAO;AAAA,UACL,QAAQA,EAAM,SACV,OAAO,KAAKA,EAAM,MAAM,EACrB,OAAO,CAACN,MAAgBA,EAAI,WAAWK,CAAW,CAAC,EACnD,OAAO,CAACE,GAAUP,OACjBO,EAAIP,CAAG,IAAIM,EAAM,OAAON,CAAG,EAAE,SAAA,GACtBO,IACN,CAAA,CAAE,IACP,CAAA;AAAA,UACJ,iBAAiBD,EAAM,kBACnB,OAAO,KAAKA,EAAM,eAAe,EAC9B,OAAO,CAACN,MAAgBA,EAAI,WAAWK,CAAW,CAAC,EACnD,OAAO,CAACE,GAAUP,OACjBO,EAAIP,CAAG,IAAI;AAAA,YACT,mBAAmBM,EAAM,gBAAgBN,CAAG,EAAE,qBAAA;AAAA,YAC9C,QAAQM,EAAM,gBAAgBN,CAAG,EAAE,UAAA;AAAA,UAAU,GAExCO,IACN,CAAA,CAAE,IACP,CAAA;AAAA,QAAC;AAAA,IAGX;AACA,WAAO;AAAA,EACT;AACF;"}

package/dist/state/observed-object.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("../reactive/context.cjs"),g=require("../reactive/effect.cjs"),C=require("../reactive/signal.cjs");var O=Object.defineProperty,d=(e,t,n)=>t in e?O(e,t,{enumerable:!0,configurable:!0,writable:!0,value:n}):e[t]=n,s=(e,t,n)=>d(e,typeof t!="symbol"?t+"":t,n);class c{constructor(){s(this,"_objectWillChange"),s(this,"_notifyCount",0);const[t,n]=C.createSignal(void 0);this._objectWillChange={getValue:t,peek:t},this._notifySetter=n}get objectWillChange(){return this._objectWillChange}notifyChange(){this._notifyCount++;const t=this._notifySetter;t&&t(void 0)}get notificationCount(){return this._notifyCount}}class y{constructor(t,n,i,r={}){s(this,"_object"),s(this,"_metadata"),s(this,"_effectCleanup"),this._object=t,this._metadata={type:"ObservedObject",propertyName:i,componentId:n.id,options:r},this.setupObservation();const o=f.getCurrentOwner();o&&o.cleanups.push(()=>{this.cleanup()})}get wrappedValue(){return this._object}get projectedValue(){return this}get metadata(){return this._metadata}setupObservation(){const t=g.createEffect(()=>{this._object.objectWillChange()});this._effectCleanup=()=>t.dispose()}cleanup(){this._effectCleanup&&(this._effectCleanup(),this._effectCleanup=void 0)}updateObject(t){this.cleanup(),this._object=t,this.setupObservation()}}const j=(e,t={})=>{const n=m(),i=v()||"observedObject";return new y(e,n,i,t)};function l(e,t={}){const n=new c;return new Proxy(e,{set(r,o,a){const p=r[o],b=Reflect.set(r,o,a);return b&&p!==a&&t.autoNotify!==!1&&n.notifyChange(),b},get(r,o){return o==="objectWillChange"?n.objectWillChange:o==="notifyChange"?()=>n.notifyChange():o==="notificationCount"?n.notificationCount:Reflect.get(r,o)}})}function _(e={}){return t=>class extends t{constructor(...n){super(...n),s(this,"_observableBase",new c),e.autoNotify!==!1&&this.setupAutoNotification()}get objectWillChange(){return this._observableBase.objectWillChange}get notificationCount(){return this._observableBase.notificationCount}notifyChange(){this._observableBase.notifyChange()}setupAutoNotification(){const n=Object.getOwnPropertyNames(this);for(const i of n){if(i.startsWith("_")||typeof this[i]=="function")continue;let r=this[i];Object.defineProperty(this,i,{get:()=>r,set:o=>{r!==o&&(r=o,this.notifyChange())},enumerable:!0,configurable:!0})}}}}function m(){const e=f.getCurrentOwner();if(!e?.context.has(u))throw new Error("@ObservedObject can only be used within a component context");return e.context.get(u)}function v(){try{const e=new Error().stack;if(e)return e.match(/at (\w+)\./)?.[1]||null}catch{}return null}const u=Symbol("TachUI.ComponentContext");function h(e){return e&&typeof e=="object"&&"objectWillChange"in e&&"notifyChange"in e}function w(e){return e&&typeof e=="object"&&"wrappedValue"in e&&"projectedValue"in e&&h(e.wrappedValue)}function W(e,t={}){return l({...e},t)}const x=j;exports.ObservableObjectBase=c;exports.ObservedObjectWrapper=x;exports.createObservableStore=W;exports.isObservableObject=h;exports.isObservedObject=w;exports.makeObservable=l;exports.observable=_;
+//# sourceMappingURL=observed-object.cjs.map

package/dist/state/observed-object.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"observed-object.cjs","sources":["../../src/state/observed-object.ts"],"sourcesContent":["/**\n * @ObservedObject Property Wrapper Implementation\n *\n * Implements SwiftUI's @ObservedObject property wrapper for observing external objects\n * that conform to the ObservableObject protocol. Automatically triggers component\n * re-renders when the observed object changes.\n */\n\nimport { getCurrentOwner } from '../reactive/context'\nimport { createEffect } from '../reactive/effect'\nimport { createSignal } from '../reactive/signal'\nimport type { Signal } from '../reactive/types'\nimport type { ComponentContext } from '../runtime/types'\nimport type {\n  ObservableObject,\n  ObservableObjectOptions,\n  ObservedObject,\n  ObservedObjectFactory,\n  PropertyWrapperMetadata,\n} from './types'\n\n/**\n * Base class for objects that can be observed\n * Provides the foundation for SwiftUI's ObservableObject protocol\n */\nexport class ObservableObjectBase implements ObservableObject {\n  private _objectWillChange: Signal<void>\n  private _notifyCount = 0\n\n  constructor() {\n    const [getNotify, setNotify] = createSignal<void>(undefined)\n    this._objectWillChange = {\n      getValue: getNotify,\n      peek: getNotify,\n    } as unknown as Signal<void>\n\n    // Track notification setter for manual triggering\n    ;(this as any)._notifySetter = setNotify\n  }\n\n  get objectWillChange(): Signal<void> {\n    return this._objectWillChange\n  }\n\n  /**\n   * Notify observers that the object has changed\n   * Call this method whenever properties of the object change\n   */\n  notifyChange(): void {\n    this._notifyCount++\n    const setter = (this as any)._notifySetter\n    if (setter) {\n      setter(undefined)\n    }\n  }\n\n  /**\n   * Get the current notification count (for debugging)\n   */\n  get notificationCount(): number {\n    return this._notifyCount\n  }\n}\n\n/**\n * Internal observed object wrapper implementation\n */\nclass ObservedObjectImpl<T extends ObservableObject> implements ObservedObject<T> {\n  private _object: T\n  private _metadata: PropertyWrapperMetadata\n  private _effectCleanup?: () => void\n\n  constructor(\n    object: T,\n    componentContext: ComponentContext,\n    propertyName: string,\n    options: ObservableObjectOptions = {}\n  ) {\n    this._object = object\n\n    // Store metadata for introspection\n    this._metadata = {\n      type: 'ObservedObject',\n      propertyName,\n      componentId: componentContext.id,\n      options,\n    }\n\n    // Register with component context for lifecycle management\n    // TODO: Integrate StateManager with ComponentContext in future version\n    // if (componentContext.stateManager) {\n    //   componentContext.stateManager.registerObservedObject(this, options)\n    // }\n\n    // Set up observation effect\n    this.setupObservation()\n\n    // Set up cleanup on component unmount\n    const owner = getCurrentOwner()\n    if (owner) {\n      owner.cleanups.push(() => {\n        this.cleanup()\n      })\n    }\n  }\n\n  get wrappedValue(): T {\n    return this._object\n  }\n\n  get projectedValue(): ObservedObject<T> {\n    return this\n  }\n\n  /**\n   * Get property wrapper metadata\n   */\n  get metadata(): PropertyWrapperMetadata {\n    return this._metadata\n  }\n\n  /**\n   * Set up reactive observation of the object\n   */\n  private setupObservation(): void {\n    // Create an effect that tracks the object's objectWillChange signal\n    const effect = createEffect(() => {\n      // Access the objectWillChange signal to create dependency\n      this._object.objectWillChange()\n\n      // The effect will re-run whenever the object notifies changes\n      // This will trigger component re-renders automatically\n    })\n    this._effectCleanup = () => effect.dispose()\n  }\n\n  /**\n   * Cleanup observation\n   */\n  private cleanup(): void {\n    if (this._effectCleanup) {\n      this._effectCleanup()\n      this._effectCleanup = undefined\n    }\n  }\n\n  /**\n   * Replace the observed object (advanced usage)\n   */\n  updateObject(newObject: T): void {\n    this.cleanup()\n    this._object = newObject\n    this.setupObservation()\n  }\n}\n\n/**\n * @ObservedObject property wrapper factory\n *\n * Creates an @ObservedObject property wrapper for observing external objects.\n * The observed object must implement the ObservableObject interface.\n *\n * @param object - The observable object to observe\n * @param options - Configuration options for the observed object wrapper\n * @returns An ObservedObject property wrapper\n *\n * @example\n * ```typescript\n * class UserData extends ObservableObjectBase {\n *   private _name = 'Unknown'\n *   private _age = 0\n *\n *   get name() { return this._name }\n *   set name(value: string) {\n *     this._name = value\n *     this.notifyChange()\n *   }\n *\n *   get age() { return this._age }\n *   set age(value: number) {\n *     this._age = value\n *     this.notifyChange()\n *   }\n * }\n *\n * class UserProfile {\n *   @ObservedObject(userData)\n *   private user: UserData\n *\n *   render() {\n *     return Text(`${this.user.name}, age ${this.user.age}`)\n *   }\n * }\n * ```\n */\nconst ObservedObjectFactory: ObservedObjectFactory = <T extends ObservableObject>(\n  object: T,\n  options: ObservableObjectOptions = {}\n): ObservedObject<T> => {\n  // This will be replaced by the decorator transformer during compilation\n  const componentContext = getCurrentComponentContext()\n  const propertyName = getCallerPropertyName() || 'observedObject'\n\n  return new ObservedObjectImpl(object, componentContext, propertyName, options)\n}\n\n/**\n * Create an observable object with automatic change notification\n *\n * @param target - The target object to make observable\n * @param options - Configuration options\n * @returns An observable version of the target object\n *\n * @example\n * ```typescript\n * const observableData = makeObservable({\n *   count: 0,\n *   name: 'Test'\n * })\n *\n * // Changes to properties will automatically trigger notifications\n * observableData.count = 10 // Triggers objectWillChange\n * ```\n */\nexport function makeObservable<T extends Record<string, any>>(\n  target: T,\n  options: ObservableObjectOptions = {}\n): T & ObservableObject {\n  const observableBase = new ObservableObjectBase()\n\n  // Create a proxy that intercepts property changes\n  const proxy = new Proxy(target, {\n    set(obj, prop, value) {\n      const oldValue = obj[prop as keyof T]\n      const result = Reflect.set(obj, prop, value)\n\n      // Only notify if the value actually changed\n      if (result && oldValue !== value && options.autoNotify !== false) {\n        observableBase.notifyChange()\n      }\n\n      return result\n    },\n\n    get(obj, prop) {\n      // Provide access to ObservableObject methods\n      if (prop === 'objectWillChange') {\n        return observableBase.objectWillChange\n      }\n      if (prop === 'notifyChange') {\n        return () => observableBase.notifyChange()\n      }\n      if (prop === 'notificationCount') {\n        return observableBase.notificationCount\n      }\n\n      return Reflect.get(obj, prop)\n    },\n  })\n\n  return proxy as T & ObservableObject\n}\n\n/**\n * Create an observable class decorator\n *\n * @param options - Configuration options\n * @returns A class decorator that makes the class observable\n *\n * @example\n * ```typescript\n * @observable()\n * class TodoItem {\n *   text: string = ''\n *   completed: boolean = false\n *\n *   toggle() {\n *     this.completed = !this.completed\n *     // Change notification happens automatically\n *   }\n * }\n * ```\n */\nexport function observable(options: ObservableObjectOptions = {}) {\n  return <T extends new (...args: any[]) => any>(constructor: T) =>\n    class extends constructor implements ObservableObject {\n      private _observableBase = new ObservableObjectBase()\n\n      get objectWillChange(): Signal<void> {\n        return this._observableBase.objectWillChange\n      }\n\n      get notificationCount(): number {\n        return this._observableBase.notificationCount\n      }\n\n      notifyChange(): void {\n        this._observableBase.notifyChange()\n      }\n\n      constructor(...args: any[]) {\n        super(...args)\n\n        // If auto-notify is enabled, set up property interception\n        if (options.autoNotify !== false) {\n          this.setupAutoNotification()\n        }\n      }\n\n      private setupAutoNotification(): void {\n        const propertyNames = Object.getOwnPropertyNames(this)\n\n        for (const propName of propertyNames) {\n          if (propName.startsWith('_') || typeof this[propName as keyof this] === 'function') {\n            continue\n          }\n\n          let value = this[propName as keyof this]\n\n          Object.defineProperty(this, propName, {\n            get: () => value,\n            set: (newValue) => {\n              if (value !== newValue) {\n                value = newValue\n                this.notifyChange()\n              }\n            },\n            enumerable: true,\n            configurable: true,\n          })\n        }\n      }\n    } as any\n}\n\n/**\n * Helper to get current component context (will be injected by compiler)\n */\nfunction getCurrentComponentContext(): ComponentContext {\n  const owner = getCurrentOwner()\n  if (!owner?.context.has(ComponentContextSymbol)) {\n    throw new Error('@ObservedObject can only be used within a component context')\n  }\n  return owner.context.get(ComponentContextSymbol) as ComponentContext\n}\n\n/**\n * Helper to get the property name of the caller (used for metadata)\n */\nfunction getCallerPropertyName(): string | null {\n  try {\n    const stack = new Error().stack\n    if (stack) {\n      const match = stack.match(/at (\\w+)\\./)?.[1]\n      return match || null\n    }\n  } catch {\n    // Ignore errors in stack parsing\n  }\n  return null\n}\n\n/**\n * Symbol for component context storage\n */\nconst ComponentContextSymbol = Symbol('TachUI.ComponentContext')\n\n/**\n * Type guard for ObservableObject\n */\nexport function isObservableObject(value: any): value is ObservableObject {\n  return (\n    value && typeof value === 'object' && 'objectWillChange' in value && 'notifyChange' in value\n  )\n}\n\n/**\n * Type guard for ObservedObject property wrapper\n */\nexport function isObservedObject<T extends ObservableObject>(\n  value: any\n): value is ObservedObject<T> {\n  return (\n    value &&\n    typeof value === 'object' &&\n    'wrappedValue' in value &&\n    'projectedValue' in value &&\n    isObservableObject(value.wrappedValue)\n  )\n}\n\n/**\n * Utility to create a simple observable store\n */\nexport function createObservableStore<T extends Record<string, any>>(\n  initialState: T,\n  options: ObservableObjectOptions = {}\n): T & ObservableObject {\n  return makeObservable({ ...initialState }, options)\n}\n\n/**\n * Export the ObservedObject factory function\n */\nexport const ObservedObjectWrapper = ObservedObjectFactory\n"],"names":["ObservableObjectBase","__publicField","getNotify","setNotify","createSignal","setter","ObservedObjectImpl","object","componentContext","propertyName","options","owner","getCurrentOwner","effect","createEffect","newObject","ObservedObjectFactory","getCurrentComponentContext","getCallerPropertyName","makeObservable","target","observableBase","obj","prop","value","oldValue","result","observable","constructor","args","propertyNames","propName","newValue","ComponentContextSymbol","stack","isObservableObject","isObservedObject","createObservableStore","initialState","ObservedObjectWrapper"],"mappings":"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"}

package/dist/state/observed-object.d.ts

@@ -0,0 +1,126 @@
+/**
+ * @ObservedObject Property Wrapper Implementation
+ *
+ * Implements SwiftUI's @ObservedObject property wrapper for observing external objects
+ * that conform to the ObservableObject protocol. Automatically triggers component
+ * re-renders when the observed object changes.
+ */
+import type { Signal } from '../reactive/types';
+import type { ObservableObject, ObservableObjectOptions, ObservedObject, ObservedObjectFactory } from './types';
+/**
+ * Base class for objects that can be observed
+ * Provides the foundation for SwiftUI's ObservableObject protocol
+ */
+export declare class ObservableObjectBase implements ObservableObject {
+    private _objectWillChange;
+    private _notifyCount;
+    constructor();
+    get objectWillChange(): Signal<void>;
+    /**
+     * Notify observers that the object has changed
+     * Call this method whenever properties of the object change
+     */
+    notifyChange(): void;
+    /**
+     * Get the current notification count (for debugging)
+     */
+    get notificationCount(): number;
+}
+/**
+ * @ObservedObject property wrapper factory
+ *
+ * Creates an @ObservedObject property wrapper for observing external objects.
+ * The observed object must implement the ObservableObject interface.
+ *
+ * @param object - The observable object to observe
+ * @param options - Configuration options for the observed object wrapper
+ * @returns An ObservedObject property wrapper
+ *
+ * @example
+ * ```typescript
+ * class UserData extends ObservableObjectBase {
+ *   private _name = 'Unknown'
+ *   private _age = 0
+ *
+ *   get name() { return this._name }
+ *   set name(value: string) {
+ *     this._name = value
+ *     this.notifyChange()
+ *   }
+ *
+ *   get age() { return this._age }
+ *   set age(value: number) {
+ *     this._age = value
+ *     this.notifyChange()
+ *   }
+ * }
+ *
+ * class UserProfile {
+ *   @ObservedObject(userData)
+ *   private user: UserData
+ *
+ *   render() {
+ *     return Text(`${this.user.name}, age ${this.user.age}`)
+ *   }
+ * }
+ * ```
+ */
+declare const ObservedObjectFactory: ObservedObjectFactory;
+/**
+ * Create an observable object with automatic change notification
+ *
+ * @param target - The target object to make observable
+ * @param options - Configuration options
+ * @returns An observable version of the target object
+ *
+ * @example
+ * ```typescript
+ * const observableData = makeObservable({
+ *   count: 0,
+ *   name: 'Test'
+ * })
+ *
+ * // Changes to properties will automatically trigger notifications
+ * observableData.count = 10 // Triggers objectWillChange
+ * ```
+ */
+export declare function makeObservable<T extends Record<string, any>>(target: T, options?: ObservableObjectOptions): T & ObservableObject;
+/**
+ * Create an observable class decorator
+ *
+ * @param options - Configuration options
+ * @returns A class decorator that makes the class observable
+ *
+ * @example
+ * ```typescript
+ * @observable()
+ * class TodoItem {
+ *   text: string = ''
+ *   completed: boolean = false
+ *
+ *   toggle() {
+ *     this.completed = !this.completed
+ *     // Change notification happens automatically
+ *   }
+ * }
+ * ```
+ */
+export declare function observable(options?: ObservableObjectOptions): <T extends new (...args: any[]) => any>(constructor: T) => any;
+/**
+ * Type guard for ObservableObject
+ */
+export declare function isObservableObject(value: any): value is ObservableObject;
+/**
+ * Type guard for ObservedObject property wrapper
+ */
+export declare function isObservedObject<T extends ObservableObject>(value: any): value is ObservedObject<T>;
+/**
+ * Utility to create a simple observable store
+ */
+export declare function createObservableStore<T extends Record<string, any>>(initialState: T, options?: ObservableObjectOptions): T & ObservableObject;
+/**
+ * Export the ObservedObject factory function
+ */
+export declare const ObservedObjectWrapper: ObservedObjectFactory;
+export {};
+//# sourceMappingURL=observed-object.d.ts.map

package/dist/state/observed-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observed-object.d.ts","sourceRoot":"","sources":["../../src/state/observed-object.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE/C,OAAO,KAAK,EACV,gBAAgB,EAChB,uBAAuB,EACvB,cAAc,EACd,qBAAqB,EAEtB,MAAM,SAAS,CAAA;AAEhB;;;GAGG;AACH,qBAAa,oBAAqB,YAAW,gBAAgB;IAC3D,OAAO,CAAC,iBAAiB,CAAc;IACvC,OAAO,CAAC,YAAY,CAAI;;IAaxB,IAAI,gBAAgB,IAAI,MAAM,CAAC,IAAI,CAAC,CAEnC;IAED;;;OAGG;IACH,YAAY,IAAI,IAAI;IAQpB;;OAEG;IACH,IAAI,iBAAiB,IAAI,MAAM,CAE9B;CACF;AA8FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,QAAA,MAAM,qBAAqB,EAAE,qBAS5B,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1D,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,uBAA4B,GACpC,CAAC,GAAG,gBAAgB,CAkCtB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,OAAO,GAAE,uBAA4B,IACtD,CAAC,SAAS,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,aAAa,CAAC,KAgDtD,GAAG,CACX;AAkCD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,gBAAgB,CAIxE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,KAAK,EAAE,GAAG,GACT,KAAK,IAAI,cAAc,CAAC,CAAC,CAAC,CAQ5B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACjE,YAAY,EAAE,CAAC,EACf,OAAO,GAAE,uBAA4B,GACpC,CAAC,GAAG,gBAAgB,CAEtB;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB,uBAAwB,CAAA"}

package/dist/state/observed-object.js

@@ -0,0 +1,163 @@
+import { getCurrentOwner as u } from "../reactive/context.js";
+import { createEffect as h } from "../reactive/effect.js";
+import { createSignal as p } from "../reactive/signal.js";
+var C = Object.defineProperty, g = (t, e, n) => e in t ? C(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n, s = (t, e, n) => g(t, typeof e != "symbol" ? e + "" : e, n);
+class b {
+  constructor() {
+    s(this, "_objectWillChange"), s(this, "_notifyCount", 0);
+    const [e, n] = p(void 0);
+    this._objectWillChange = {
+      getValue: e,
+      peek: e
+    }, this._notifySetter = n;
+  }
+  get objectWillChange() {
+    return this._objectWillChange;
+  }
+  /**
+   * Notify observers that the object has changed
+   * Call this method whenever properties of the object change
+   */
+  notifyChange() {
+    this._notifyCount++;
+    const e = this._notifySetter;
+    e && e(void 0);
+  }
+  /**
+   * Get the current notification count (for debugging)
+   */
+  get notificationCount() {
+    return this._notifyCount;
+  }
+}
+class y {
+  constructor(e, n, i, r = {}) {
+    s(this, "_object"), s(this, "_metadata"), s(this, "_effectCleanup"), this._object = e, this._metadata = {
+      type: "ObservedObject",
+      propertyName: i,
+      componentId: n.id,
+      options: r
+    }, this.setupObservation();
+    const o = u();
+    o && o.cleanups.push(() => {
+      this.cleanup();
+    });
+  }
+  get wrappedValue() {
+    return this._object;
+  }
+  get projectedValue() {
+    return this;
+  }
+  /**
+   * Get property wrapper metadata
+   */
+  get metadata() {
+    return this._metadata;
+  }
+  /**
+   * Set up reactive observation of the object
+   */
+  setupObservation() {
+    const e = h(() => {
+      this._object.objectWillChange();
+    });
+    this._effectCleanup = () => e.dispose();
+  }
+  /**
+   * Cleanup observation
+   */
+  cleanup() {
+    this._effectCleanup && (this._effectCleanup(), this._effectCleanup = void 0);
+  }
+  /**
+   * Replace the observed object (advanced usage)
+   */
+  updateObject(e) {
+    this.cleanup(), this._object = e, this.setupObservation();
+  }
+}
+const m = (t, e = {}) => {
+  const n = d(), i = j() || "observedObject";
+  return new y(t, n, i, e);
+};
+function _(t, e = {}) {
+  const n = new b();
+  return new Proxy(t, {
+    set(r, o, c) {
+      const l = r[o], a = Reflect.set(r, o, c);
+      return a && l !== c && e.autoNotify !== !1 && n.notifyChange(), a;
+    },
+    get(r, o) {
+      return o === "objectWillChange" ? n.objectWillChange : o === "notifyChange" ? () => n.notifyChange() : o === "notificationCount" ? n.notificationCount : Reflect.get(r, o);
+    }
+  });
+}
+function N(t = {}) {
+  return (e) => class extends e {
+    constructor(...n) {
+      super(...n), s(this, "_observableBase", new b()), t.autoNotify !== !1 && this.setupAutoNotification();
+    }
+    get objectWillChange() {
+      return this._observableBase.objectWillChange;
+    }
+    get notificationCount() {
+      return this._observableBase.notificationCount;
+    }
+    notifyChange() {
+      this._observableBase.notifyChange();
+    }
+    setupAutoNotification() {
+      const n = Object.getOwnPropertyNames(this);
+      for (const i of n) {
+        if (i.startsWith("_") || typeof this[i] == "function")
+          continue;
+        let r = this[i];
+        Object.defineProperty(this, i, {
+          get: () => r,
+          set: (o) => {
+            r !== o && (r = o, this.notifyChange());
+          },
+          enumerable: !0,
+          configurable: !0
+        });
+      }
+    }
+  };
+}
+function d() {
+  const t = u();
+  if (!t?.context.has(f))
+    throw new Error("@ObservedObject can only be used within a component context");
+  return t.context.get(f);
+}
+function j() {
+  try {
+    const t = new Error().stack;
+    if (t)
+      return t.match(/at (\w+)\./)?.[1] || null;
+  } catch {
+  }
+  return null;
+}
+const f = Symbol("TachUI.ComponentContext");
+function O(t) {
+  return t && typeof t == "object" && "objectWillChange" in t && "notifyChange" in t;
+}
+function W(t) {
+  return t && typeof t == "object" && "wrappedValue" in t && "projectedValue" in t && O(t.wrappedValue);
+}
+function P(t, e = {}) {
+  return _({ ...t }, e);
+}
+const B = m;
+export {
+  b as ObservableObjectBase,
+  B as ObservedObjectWrapper,
+  P as createObservableStore,
+  O as isObservableObject,
+  W as isObservedObject,
+  _ as makeObservable,
+  N as observable
+};
+//# sourceMappingURL=observed-object.js.map

package/dist/state/observed-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observed-object.js","sources":["../../src/state/observed-object.ts"],"sourcesContent":["/**\n * @ObservedObject Property Wrapper Implementation\n *\n * Implements SwiftUI's @ObservedObject property wrapper for observing external objects\n * that conform to the ObservableObject protocol. Automatically triggers component\n * re-renders when the observed object changes.\n */\n\nimport { getCurrentOwner } from '../reactive/context'\nimport { createEffect } from '../reactive/effect'\nimport { createSignal } from '../reactive/signal'\nimport type { Signal } from '../reactive/types'\nimport type { ComponentContext } from '../runtime/types'\nimport type {\n  ObservableObject,\n  ObservableObjectOptions,\n  ObservedObject,\n  ObservedObjectFactory,\n  PropertyWrapperMetadata,\n} from './types'\n\n/**\n * Base class for objects that can be observed\n * Provides the foundation for SwiftUI's ObservableObject protocol\n */\nexport class ObservableObjectBase implements ObservableObject {\n  private _objectWillChange: Signal<void>\n  private _notifyCount = 0\n\n  constructor() {\n    const [getNotify, setNotify] = createSignal<void>(undefined)\n    this._objectWillChange = {\n      getValue: getNotify,\n      peek: getNotify,\n    } as unknown as Signal<void>\n\n    // Track notification setter for manual triggering\n    ;(this as any)._notifySetter = setNotify\n  }\n\n  get objectWillChange(): Signal<void> {\n    return this._objectWillChange\n  }\n\n  /**\n   * Notify observers that the object has changed\n   * Call this method whenever properties of the object change\n   */\n  notifyChange(): void {\n    this._notifyCount++\n    const setter = (this as any)._notifySetter\n    if (setter) {\n      setter(undefined)\n    }\n  }\n\n  /**\n   * Get the current notification count (for debugging)\n   */\n  get notificationCount(): number {\n    return this._notifyCount\n  }\n}\n\n/**\n * Internal observed object wrapper implementation\n */\nclass ObservedObjectImpl<T extends ObservableObject> implements ObservedObject<T> {\n  private _object: T\n  private _metadata: PropertyWrapperMetadata\n  private _effectCleanup?: () => void\n\n  constructor(\n    object: T,\n    componentContext: ComponentContext,\n    propertyName: string,\n    options: ObservableObjectOptions = {}\n  ) {\n    this._object = object\n\n    // Store metadata for introspection\n    this._metadata = {\n      type: 'ObservedObject',\n      propertyName,\n      componentId: componentContext.id,\n      options,\n    }\n\n    // Register with component context for lifecycle management\n    // TODO: Integrate StateManager with ComponentContext in future version\n    // if (componentContext.stateManager) {\n    //   componentContext.stateManager.registerObservedObject(this, options)\n    // }\n\n    // Set up observation effect\n    this.setupObservation()\n\n    // Set up cleanup on component unmount\n    const owner = getCurrentOwner()\n    if (owner) {\n      owner.cleanups.push(() => {\n        this.cleanup()\n      })\n    }\n  }\n\n  get wrappedValue(): T {\n    return this._object\n  }\n\n  get projectedValue(): ObservedObject<T> {\n    return this\n  }\n\n  /**\n   * Get property wrapper metadata\n   */\n  get metadata(): PropertyWrapperMetadata {\n    return this._metadata\n  }\n\n  /**\n   * Set up reactive observation of the object\n   */\n  private setupObservation(): void {\n    // Create an effect that tracks the object's objectWillChange signal\n    const effect = createEffect(() => {\n      // Access the objectWillChange signal to create dependency\n      this._object.objectWillChange()\n\n      // The effect will re-run whenever the object notifies changes\n      // This will trigger component re-renders automatically\n    })\n    this._effectCleanup = () => effect.dispose()\n  }\n\n  /**\n   * Cleanup observation\n   */\n  private cleanup(): void {\n    if (this._effectCleanup) {\n      this._effectCleanup()\n      this._effectCleanup = undefined\n    }\n  }\n\n  /**\n   * Replace the observed object (advanced usage)\n   */\n  updateObject(newObject: T): void {\n    this.cleanup()\n    this._object = newObject\n    this.setupObservation()\n  }\n}\n\n/**\n * @ObservedObject property wrapper factory\n *\n * Creates an @ObservedObject property wrapper for observing external objects.\n * The observed object must implement the ObservableObject interface.\n *\n * @param object - The observable object to observe\n * @param options - Configuration options for the observed object wrapper\n * @returns An ObservedObject property wrapper\n *\n * @example\n * ```typescript\n * class UserData extends ObservableObjectBase {\n *   private _name = 'Unknown'\n *   private _age = 0\n *\n *   get name() { return this._name }\n *   set name(value: string) {\n *     this._name = value\n *     this.notifyChange()\n *   }\n *\n *   get age() { return this._age }\n *   set age(value: number) {\n *     this._age = value\n *     this.notifyChange()\n *   }\n * }\n *\n * class UserProfile {\n *   @ObservedObject(userData)\n *   private user: UserData\n *\n *   render() {\n *     return Text(`${this.user.name}, age ${this.user.age}`)\n *   }\n * }\n * ```\n */\nconst ObservedObjectFactory: ObservedObjectFactory = <T extends ObservableObject>(\n  object: T,\n  options: ObservableObjectOptions = {}\n): ObservedObject<T> => {\n  // This will be replaced by the decorator transformer during compilation\n  const componentContext = getCurrentComponentContext()\n  const propertyName = getCallerPropertyName() || 'observedObject'\n\n  return new ObservedObjectImpl(object, componentContext, propertyName, options)\n}\n\n/**\n * Create an observable object with automatic change notification\n *\n * @param target - The target object to make observable\n * @param options - Configuration options\n * @returns An observable version of the target object\n *\n * @example\n * ```typescript\n * const observableData = makeObservable({\n *   count: 0,\n *   name: 'Test'\n * })\n *\n * // Changes to properties will automatically trigger notifications\n * observableData.count = 10 // Triggers objectWillChange\n * ```\n */\nexport function makeObservable<T extends Record<string, any>>(\n  target: T,\n  options: ObservableObjectOptions = {}\n): T & ObservableObject {\n  const observableBase = new ObservableObjectBase()\n\n  // Create a proxy that intercepts property changes\n  const proxy = new Proxy(target, {\n    set(obj, prop, value) {\n      const oldValue = obj[prop as keyof T]\n      const result = Reflect.set(obj, prop, value)\n\n      // Only notify if the value actually changed\n      if (result && oldValue !== value && options.autoNotify !== false) {\n        observableBase.notifyChange()\n      }\n\n      return result\n    },\n\n    get(obj, prop) {\n      // Provide access to ObservableObject methods\n      if (prop === 'objectWillChange') {\n        return observableBase.objectWillChange\n      }\n      if (prop === 'notifyChange') {\n        return () => observableBase.notifyChange()\n      }\n      if (prop === 'notificationCount') {\n        return observableBase.notificationCount\n      }\n\n      return Reflect.get(obj, prop)\n    },\n  })\n\n  return proxy as T & ObservableObject\n}\n\n/**\n * Create an observable class decorator\n *\n * @param options - Configuration options\n * @returns A class decorator that makes the class observable\n *\n * @example\n * ```typescript\n * @observable()\n * class TodoItem {\n *   text: string = ''\n *   completed: boolean = false\n *\n *   toggle() {\n *     this.completed = !this.completed\n *     // Change notification happens automatically\n *   }\n * }\n * ```\n */\nexport function observable(options: ObservableObjectOptions = {}) {\n  return <T extends new (...args: any[]) => any>(constructor: T) =>\n    class extends constructor implements ObservableObject {\n      private _observableBase = new ObservableObjectBase()\n\n      get objectWillChange(): Signal<void> {\n        return this._observableBase.objectWillChange\n      }\n\n      get notificationCount(): number {\n        return this._observableBase.notificationCount\n      }\n\n      notifyChange(): void {\n        this._observableBase.notifyChange()\n      }\n\n      constructor(...args: any[]) {\n        super(...args)\n\n        // If auto-notify is enabled, set up property interception\n        if (options.autoNotify !== false) {\n          this.setupAutoNotification()\n        }\n      }\n\n      private setupAutoNotification(): void {\n        const propertyNames = Object.getOwnPropertyNames(this)\n\n        for (const propName of propertyNames) {\n          if (propName.startsWith('_') || typeof this[propName as keyof this] === 'function') {\n            continue\n          }\n\n          let value = this[propName as keyof this]\n\n          Object.defineProperty(this, propName, {\n            get: () => value,\n            set: (newValue) => {\n              if (value !== newValue) {\n                value = newValue\n                this.notifyChange()\n              }\n            },\n            enumerable: true,\n            configurable: true,\n          })\n        }\n      }\n    } as any\n}\n\n/**\n * Helper to get current component context (will be injected by compiler)\n */\nfunction getCurrentComponentContext(): ComponentContext {\n  const owner = getCurrentOwner()\n  if (!owner?.context.has(ComponentContextSymbol)) {\n    throw new Error('@ObservedObject can only be used within a component context')\n  }\n  return owner.context.get(ComponentContextSymbol) as ComponentContext\n}\n\n/**\n * Helper to get the property name of the caller (used for metadata)\n */\nfunction getCallerPropertyName(): string | null {\n  try {\n    const stack = new Error().stack\n    if (stack) {\n      const match = stack.match(/at (\\w+)\\./)?.[1]\n      return match || null\n    }\n  } catch {\n    // Ignore errors in stack parsing\n  }\n  return null\n}\n\n/**\n * Symbol for component context storage\n */\nconst ComponentContextSymbol = Symbol('TachUI.ComponentContext')\n\n/**\n * Type guard for ObservableObject\n */\nexport function isObservableObject(value: any): value is ObservableObject {\n  return (\n    value && typeof value === 'object' && 'objectWillChange' in value && 'notifyChange' in value\n  )\n}\n\n/**\n * Type guard for ObservedObject property wrapper\n */\nexport function isObservedObject<T extends ObservableObject>(\n  value: any\n): value is ObservedObject<T> {\n  return (\n    value &&\n    typeof value === 'object' &&\n    'wrappedValue' in value &&\n    'projectedValue' in value &&\n    isObservableObject(value.wrappedValue)\n  )\n}\n\n/**\n * Utility to create a simple observable store\n */\nexport function createObservableStore<T extends Record<string, any>>(\n  initialState: T,\n  options: ObservableObjectOptions = {}\n): T & ObservableObject {\n  return makeObservable({ ...initialState }, options)\n}\n\n/**\n * Export the ObservedObject factory function\n */\nexport const ObservedObjectWrapper = ObservedObjectFactory\n"],"names":["ObservableObjectBase","__publicField","getNotify","setNotify","createSignal","setter","ObservedObjectImpl","object","componentContext","propertyName","options","owner","getCurrentOwner","effect","createEffect","newObject","ObservedObjectFactory","getCurrentComponentContext","getCallerPropertyName","makeObservable","target","observableBase","obj","prop","value","oldValue","result","observable","constructor","args","propertyNames","propName","newValue","ComponentContextSymbol","stack","isObservableObject","isObservedObject","createObservableStore","initialState","ObservedObjectWrapper"],"mappings":"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"}

package/dist/state/state-manager.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var b=Object.defineProperty,m=(a,e,n)=>e in a?b(a,e,{enumerable:!0,configurable:!0,writable:!0,value:n}):a[e]=n,r=(a,e,n)=>m(a,typeof e!="symbol"?e+"":e,n);class o{constructor(e){this.componentContext=e,r(this,"states",new Map),r(this,"bindings",new Map),r(this,"observedObjects",new Map),r(this,"environmentObjects",new Map),r(this,"registry"),this.registry=new _}registerState(e,n={}){const t=e.metadata;if(t){const s=`${t.componentId}_${t.propertyName}`;this.states.set(s,e),this.registry.register(t),process.env.NODE_ENV==="development"&&this.setupStateDebugging(e,t)}}registerBinding(e,n={}){const t=`${this.componentContext.id}_${n.name||"binding"}_${Date.now()}`;this.bindings.set(t,e);const s={type:"Binding",propertyName:n.name||"binding",componentId:this.componentContext.id,options:n};this.registry.register(s)}registerObservedObject(e,n={}){const t=e.metadata;if(t){const s=`${t.componentId}_${t.propertyName}`;this.observedObjects.set(s,e),this.registry.register(t),process.env.NODE_ENV==="development"&&this.setupObservedObjectDebugging(e,t)}}registerEnvironmentObject(e,n){const t=e.metadata;if(t){const s=`${t.componentId}_${t.propertyName}`;this.environmentObjects.set(s,e),this.registry.register(t)}}cleanup(){this.states.clear(),this.bindings.clear(),this.observedObjects.clear(),this.environmentObjects.clear(),this.registry.cleanup(this.componentContext.id)}getStates(){return new Map(this.states)}getBindings(){return new Map(this.bindings)}getObservedObjects(){return new Map(this.observedObjects)}getEnvironmentObjects(){return new Map(this.environmentObjects)}getRegistry(){return this.registry}setupStateDebugging(e,n){if(typeof window<"u"){const t=window.__TACHUI_DEBUG__||{};t.states||(t.states={}),t.states[`${n.componentId}_${n.propertyName}`]={state:e,metadata:n,getValue:()=>e.wrappedValue,setValue:s=>{e.projectedValue.set(s)},getBinding:()=>e.projectedValue},window.__TACHUI_DEBUG__=t}}setupObservedObjectDebugging(e,n){if(typeof window<"u"){const t=window.__TACHUI_DEBUG__||{};t.observedObjects||(t.observedObjects={}),t.observedObjects[`${n.componentId}_${n.propertyName}`]={observedObject:e,metadata:n,getObject:()=>e.wrappedValue,getNotificationCount:()=>e.wrappedValue.notificationCount||0,triggerChange:()=>e.wrappedValue.notifyChange()},window.__TACHUI_DEBUG__=t}}}class _{constructor(){r(this,"metadata",new Map)}register(e){const n=e.componentId,t=this.metadata.get(n)||[];t.push(e),this.metadata.set(n,t)}unregister(e,n){const s=(this.metadata.get(e)||[]).filter(l=>l.propertyName!==n);s.length>0?this.metadata.set(e,s):this.metadata.delete(e)}cleanup(e){this.metadata.delete(e)}getMetadata(e){return this.metadata.get(e)||[]}getAllMetadata(){return new Map(this.metadata)}}function h(a){return new o(a)}const c=class i{constructor(){r(this,"managers",new Map)}static getInstance(){return i.instance||(i.instance=new i),i.instance}register(e,n){this.managers.set(e,n)}unregister(e){this.managers.delete(e)}getManager(e){return this.managers.get(e)}getAllManagers(){return new Map(this.managers)}getDebugInfo(){const e={};for(const[n,t]of this.managers)e[n]={states:t.getStates().size,bindings:t.getBindings().size,observedObjects:t.getObservedObjects().size,environmentObjects:t.getEnvironmentObjects().size,metadata:t.getRegistry().getMetadata(n)};return e}};r(c,"instance");let g=c;function f(a,e){g.getInstance().register(a,e)}function w(a){g.getInstance().unregister(a)}function d(a){return g.getInstance().getManager(a)}function p(){return g.getInstance().getAllManagers()}function u(){return g.getInstance().getDebugInfo()}function M(){if(typeof window<"u"&&process.env.NODE_ENV==="development"){const a=window.__TACHUI_DEBUG__||{};a.stateManagers={getAll:p,getDebugInfo:u,getManager:d},window.__TACHUI_DEBUG__=a,console.log("TachUI State Management debugging enabled. Use window.__TACHUI_DEBUG__.stateManagers")}}exports.StateManagerImpl=o;exports.createStateManager=h;exports.getAllStateManagers=p;exports.getStateManager=d;exports.getStateManagerDebugInfo=u;exports.initializeStateDebugging=M;exports.registerStateManager=f;exports.unregisterStateManager=w;
+//# sourceMappingURL=state-manager.cjs.map

package/dist/state/state-manager.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-manager.cjs","sources":["../../src/state/state-manager.ts"],"sourcesContent":["/**\n * State Manager Implementation\n *\n * Manages the lifecycle of all property wrappers (@State, @Binding, @ObservedObject, @EnvironmentObject)\n * within a component context. Handles registration, cleanup, and debugging utilities.\n */\n\nimport type { ComponentContext } from '../runtime/types'\nimport type {\n  Binding,\n  BindingOptions,\n  EnvironmentObject,\n  EnvironmentObjectOptions,\n  ObservableObject,\n  ObservableObjectOptions,\n  ObservedObject,\n  PropertyWrapperMetadata,\n  PropertyWrapperRegistry,\n  State,\n  StateManager,\n  StateWrapperOptions,\n} from './types'\n\n/**\n * Internal state manager implementation\n */\nexport class StateManagerImpl implements StateManager {\n  private states = new Map<string, State<any>>()\n  private bindings = new Map<string, Binding<any>>()\n  private observedObjects = new Map<string, ObservedObject<any>>()\n  private environmentObjects = new Map<string, EnvironmentObject<any>>()\n  private registry: PropertyWrapperRegistry\n\n  constructor(public readonly componentContext: ComponentContext) {\n    this.registry = new PropertyWrapperRegistryImpl()\n  }\n\n  /**\n   * Register a @State property wrapper\n   */\n  registerState<T>(state: State<T>, _options: StateWrapperOptions = {}): void {\n    const metadata = (state as any).metadata as PropertyWrapperMetadata\n    if (metadata) {\n      const key = `${metadata.componentId}_${metadata.propertyName}`\n      this.states.set(key, state)\n      this.registry.register(metadata)\n\n      // Set up debugging if in development mode\n      if (process.env.NODE_ENV === 'development') {\n        this.setupStateDebugging(state, metadata)\n      }\n    }\n  }\n\n  /**\n   * Register a @Binding property wrapper\n   */\n  registerBinding<T>(binding: Binding<T>, options: BindingOptions<T> = {}): void {\n    const key = `${this.componentContext.id}_${options.name || 'binding'}_${Date.now()}`\n    this.bindings.set(key, binding)\n\n    const metadata: PropertyWrapperMetadata = {\n      type: 'Binding',\n      propertyName: options.name || 'binding',\n      componentId: this.componentContext.id,\n      options,\n    }\n    this.registry.register(metadata)\n  }\n\n  /**\n   * Register an @ObservedObject property wrapper\n   */\n  registerObservedObject<T extends ObservableObject>(\n    observedObject: ObservedObject<T>,\n    _options: ObservableObjectOptions = {}\n  ): void {\n    const metadata = (observedObject as any).metadata as PropertyWrapperMetadata\n    if (metadata) {\n      const key = `${metadata.componentId}_${metadata.propertyName}`\n      this.observedObjects.set(key, observedObject)\n      this.registry.register(metadata)\n\n      // Set up debugging if in development mode\n      if (process.env.NODE_ENV === 'development') {\n        this.setupObservedObjectDebugging(observedObject, metadata)\n      }\n    }\n  }\n\n  /**\n   * Register an @EnvironmentObject property wrapper\n   */\n  registerEnvironmentObject<T>(\n    environmentObject: EnvironmentObject<T>,\n    _options: EnvironmentObjectOptions<T>\n  ): void {\n    const metadata = (environmentObject as any).metadata as PropertyWrapperMetadata\n    if (metadata) {\n      const key = `${metadata.componentId}_${metadata.propertyName}`\n      this.environmentObjects.set(key, environmentObject)\n      this.registry.register(metadata)\n    }\n  }\n\n  /**\n   * Clean up all property wrappers for this component\n   */\n  cleanup(): void {\n    // Clear all registered property wrappers\n    this.states.clear()\n    this.bindings.clear()\n    this.observedObjects.clear()\n    this.environmentObjects.clear()\n\n    // Clean up registry\n    this.registry.cleanup(this.componentContext.id)\n  }\n\n  /**\n   * Get all registered states (for debugging)\n   */\n  getStates(): Map<string, State<any>> {\n    return new Map(this.states)\n  }\n\n  /**\n   * Get all registered bindings (for debugging)\n   */\n  getBindings(): Map<string, Binding<any>> {\n    return new Map(this.bindings)\n  }\n\n  /**\n   * Get all registered observed objects (for debugging)\n   */\n  getObservedObjects(): Map<string, ObservedObject<any>> {\n    return new Map(this.observedObjects)\n  }\n\n  /**\n   * Get all registered environment objects (for debugging)\n   */\n  getEnvironmentObjects(): Map<string, EnvironmentObject<any>> {\n    return new Map(this.environmentObjects)\n  }\n\n  /**\n   * Get property wrapper registry\n   */\n  getRegistry(): PropertyWrapperRegistry {\n    return this.registry\n  }\n\n  /**\n   * Set up debugging for @State property wrappers\n   */\n  private setupStateDebugging<T>(state: State<T>, metadata: PropertyWrapperMetadata): void {\n    if (typeof window !== 'undefined') {\n      // Add to global debug object\n      const globalDebug = (window as any).__TACHUI_DEBUG__ || {}\n      if (!globalDebug.states) globalDebug.states = {}\n\n      globalDebug.states[`${metadata.componentId}_${metadata.propertyName}`] = {\n        state,\n        metadata,\n        getValue: () => state.wrappedValue,\n        setValue: (value: T) => {\n          state.projectedValue.set(value)\n        },\n        getBinding: () => state.projectedValue,\n      }\n\n      ;(window as any).__TACHUI_DEBUG__ = globalDebug\n    }\n  }\n\n  /**\n   * Set up debugging for @ObservedObject property wrappers\n   */\n  private setupObservedObjectDebugging<T extends ObservableObject>(\n    observedObject: ObservedObject<T>,\n    metadata: PropertyWrapperMetadata\n  ): void {\n    if (typeof window !== 'undefined') {\n      // Add to global debug object\n      const globalDebug = (window as any).__TACHUI_DEBUG__ || {}\n      if (!globalDebug.observedObjects) globalDebug.observedObjects = {}\n\n      globalDebug.observedObjects[`${metadata.componentId}_${metadata.propertyName}`] = {\n        observedObject,\n        metadata,\n        getObject: () => observedObject.wrappedValue,\n        getNotificationCount: () => (observedObject.wrappedValue as any).notificationCount || 0,\n        triggerChange: () => observedObject.wrappedValue.notifyChange(),\n      }\n\n      ;(window as any).__TACHUI_DEBUG__ = globalDebug\n    }\n  }\n}\n\n/**\n * Property wrapper registry implementation\n */\nclass PropertyWrapperRegistryImpl implements PropertyWrapperRegistry {\n  private metadata = new Map<string, PropertyWrapperMetadata[]>()\n\n  /**\n   * Register property wrapper metadata\n   */\n  register(metadata: PropertyWrapperMetadata): void {\n    const key = metadata.componentId\n    const existing = this.metadata.get(key) || []\n    existing.push(metadata)\n    this.metadata.set(key, existing)\n  }\n\n  /**\n   * Unregister a specific property wrapper\n   */\n  unregister(componentId: string, propertyName: string): void {\n    const existing = this.metadata.get(componentId) || []\n    const filtered = existing.filter((m) => m.propertyName !== propertyName)\n\n    if (filtered.length > 0) {\n      this.metadata.set(componentId, filtered)\n    } else {\n      this.metadata.delete(componentId)\n    }\n  }\n\n  /**\n   * Clean up all metadata for a component\n   */\n  cleanup(componentId: string): void {\n    this.metadata.delete(componentId)\n  }\n\n  /**\n   * Get all metadata for a component\n   */\n  getMetadata(componentId: string): PropertyWrapperMetadata[] {\n    return this.metadata.get(componentId) || []\n  }\n\n  /**\n   * Get all registered metadata (for debugging)\n   */\n  getAllMetadata(): Map<string, PropertyWrapperMetadata[]> {\n    return new Map(this.metadata)\n  }\n}\n\n/**\n * Create a state manager for a component\n */\nexport function createStateManager(componentContext: ComponentContext): StateManager {\n  return new StateManagerImpl(componentContext)\n}\n\n/**\n * Global state manager registry for debugging and introspection\n */\nclass GlobalStateManagerRegistry {\n  private static instance: GlobalStateManagerRegistry\n  private managers = new Map<string, StateManager>()\n\n  static getInstance(): GlobalStateManagerRegistry {\n    if (!GlobalStateManagerRegistry.instance) {\n      GlobalStateManagerRegistry.instance = new GlobalStateManagerRegistry()\n    }\n    return GlobalStateManagerRegistry.instance\n  }\n\n  register(componentId: string, manager: StateManager): void {\n    this.managers.set(componentId, manager)\n  }\n\n  unregister(componentId: string): void {\n    this.managers.delete(componentId)\n  }\n\n  getManager(componentId: string): StateManager | undefined {\n    return this.managers.get(componentId)\n  }\n\n  getAllManagers(): Map<string, StateManager> {\n    return new Map(this.managers)\n  }\n\n  /**\n   * Get debugging information for all components\n   */\n  getDebugInfo(): any {\n    const info: any = {}\n\n    for (const [componentId, manager] of this.managers) {\n      info[componentId] = {\n        states: (manager as StateManagerImpl).getStates().size,\n        bindings: (manager as StateManagerImpl).getBindings().size,\n        observedObjects: (manager as StateManagerImpl).getObservedObjects().size,\n        environmentObjects: (manager as StateManagerImpl).getEnvironmentObjects().size,\n        metadata: (manager as StateManagerImpl).getRegistry().getMetadata(componentId),\n      }\n    }\n\n    return info\n  }\n}\n\n/**\n * Register a state manager globally\n */\nexport function registerStateManager(componentId: string, manager: StateManager): void {\n  GlobalStateManagerRegistry.getInstance().register(componentId, manager)\n}\n\n/**\n * Unregister a state manager globally\n */\nexport function unregisterStateManager(componentId: string): void {\n  GlobalStateManagerRegistry.getInstance().unregister(componentId)\n}\n\n/**\n * Get a state manager by component ID\n */\nexport function getStateManager(componentId: string): StateManager | undefined {\n  return GlobalStateManagerRegistry.getInstance().getManager(componentId)\n}\n\n/**\n * Get all state managers (for debugging)\n */\nexport function getAllStateManagers(): Map<string, StateManager> {\n  return GlobalStateManagerRegistry.getInstance().getAllManagers()\n}\n\n/**\n * Get debugging information for all state managers\n */\nexport function getStateManagerDebugInfo(): any {\n  return GlobalStateManagerRegistry.getInstance().getDebugInfo()\n}\n\n/**\n * Initialize global debugging utilities\n */\nexport function initializeStateDebugging(): void {\n  if (typeof window !== 'undefined' && process.env.NODE_ENV === 'development') {\n    const globalDebug = (window as any).__TACHUI_DEBUG__ || {}\n\n    globalDebug.stateManagers = {\n      getAll: getAllStateManagers,\n      getDebugInfo: getStateManagerDebugInfo,\n      getManager: getStateManager,\n    }\n\n    ;(window as any).__TACHUI_DEBUG__ = globalDebug\n\n    console.log(\n      'TachUI State Management debugging enabled. Use window.__TACHUI_DEBUG__.stateManagers'\n    )\n  }\n}\n"],"names":["StateManagerImpl","componentContext","__publicField","PropertyWrapperRegistryImpl","state","_options","metadata","key","binding","options","observedObject","environmentObject","globalDebug","value","existing","componentId","propertyName","filtered","m","createStateManager","_GlobalStateManagerRegistry","manager","info","GlobalStateManagerRegistry","registerStateManager","unregisterStateManager","getStateManager","getAllStateManagers","getStateManagerDebugInfo","initializeStateDebugging"],"mappings":"4OA0BO,MAAMA,CAAyC,CAOpD,YAA4BC,EAAoC,CAApC,KAAA,iBAAAA,EAN5BC,EAAA,KAAQ,aAAa,GAAwB,EAC7CA,EAAA,KAAQ,eAAe,GAA0B,EACjDA,EAAA,KAAQ,sBAAsB,GAAiC,EAC/DA,EAAA,KAAQ,yBAAyB,GAAoC,EACrEA,EAAA,KAAQ,UAAA,EAGN,KAAK,SAAW,IAAIC,CACtB,CAKA,cAAiBC,EAAiBC,EAAgC,GAAU,CAC1E,MAAMC,EAAYF,EAAc,SAChC,GAAIE,EAAU,CACZ,MAAMC,EAAM,GAAGD,EAAS,WAAW,IAAIA,EAAS,YAAY,GAC5D,KAAK,OAAO,IAAIC,EAAKH,CAAK,EAC1B,KAAK,SAAS,SAASE,CAAQ,EAG3B,QAAQ,IAAI,WAAa,eAC3B,KAAK,oBAAoBF,EAAOE,CAAQ,CAE5C,CACF,CAKA,gBAAmBE,EAAqBC,EAA6B,GAAU,CAC7E,MAAMF,EAAM,GAAG,KAAK,iBAAiB,EAAE,IAAIE,EAAQ,MAAQ,SAAS,IAAI,KAAK,IAAA,CAAK,GAClF,KAAK,SAAS,IAAIF,EAAKC,CAAO,EAE9B,MAAMF,EAAoC,CACxC,KAAM,UACN,aAAcG,EAAQ,MAAQ,UAC9B,YAAa,KAAK,iBAAiB,GACnC,QAAAA,CAAA,EAEF,KAAK,SAAS,SAASH,CAAQ,CACjC,CAKA,uBACEI,EACAL,EAAoC,GAC9B,CACN,MAAMC,EAAYI,EAAuB,SACzC,GAAIJ,EAAU,CACZ,MAAMC,EAAM,GAAGD,EAAS,WAAW,IAAIA,EAAS,YAAY,GAC5D,KAAK,gBAAgB,IAAIC,EAAKG,CAAc,EAC5C,KAAK,SAAS,SAASJ,CAAQ,EAG3B,QAAQ,IAAI,WAAa,eAC3B,KAAK,6BAA6BI,EAAgBJ,CAAQ,CAE9D,CACF,CAKA,0BACEK,EACAN,EACM,CACN,MAAMC,EAAYK,EAA0B,SAC5C,GAAIL,EAAU,CACZ,MAAMC,EAAM,GAAGD,EAAS,WAAW,IAAIA,EAAS,YAAY,GAC5D,KAAK,mBAAmB,IAAIC,EAAKI,CAAiB,EAClD,KAAK,SAAS,SAASL,CAAQ,CACjC,CACF,CAKA,SAAgB,CAEd,KAAK,OAAO,MAAA,EACZ,KAAK,SAAS,MAAA,EACd,KAAK,gBAAgB,MAAA,EACrB,KAAK,mBAAmB,MAAA,EAGxB,KAAK,SAAS,QAAQ,KAAK,iBAAiB,EAAE,CAChD,CAKA,WAAqC,CACnC,OAAO,IAAI,IAAI,KAAK,MAAM,CAC5B,CAKA,aAAyC,CACvC,OAAO,IAAI,IAAI,KAAK,QAAQ,CAC9B,CAKA,oBAAuD,CACrD,OAAO,IAAI,IAAI,KAAK,eAAe,CACrC,CAKA,uBAA6D,CAC3D,OAAO,IAAI,IAAI,KAAK,kBAAkB,CACxC,CAKA,aAAuC,CACrC,OAAO,KAAK,QACd,CAKQ,oBAAuBF,EAAiBE,EAAyC,CACvF,GAAI,OAAO,OAAW,IAAa,CAEjC,MAAMM,EAAe,OAAe,kBAAoB,CAAA,EACnDA,EAAY,SAAQA,EAAY,OAAS,CAAA,GAE9CA,EAAY,OAAO,GAAGN,EAAS,WAAW,IAAIA,EAAS,YAAY,EAAE,EAAI,CACvE,MAAAF,EACA,SAAAE,EACA,SAAU,IAAMF,EAAM,aACtB,SAAWS,GAAa,CACtBT,EAAM,eAAe,IAAIS,CAAK,CAChC,EACA,WAAY,IAAMT,EAAM,cAAA,EAGxB,OAAe,iBAAmBQ,CACtC,CACF,CAKQ,6BACNF,EACAJ,EACM,CACN,GAAI,OAAO,OAAW,IAAa,CAEjC,MAAMM,EAAe,OAAe,kBAAoB,CAAA,EACnDA,EAAY,kBAAiBA,EAAY,gBAAkB,CAAA,GAEhEA,EAAY,gBAAgB,GAAGN,EAAS,WAAW,IAAIA,EAAS,YAAY,EAAE,EAAI,CAChF,eAAAI,EACA,SAAAJ,EACA,UAAW,IAAMI,EAAe,aAChC,qBAAsB,IAAOA,EAAe,aAAqB,mBAAqB,EACtF,cAAe,IAAMA,EAAe,aAAa,aAAA,CAAa,EAG9D,OAAe,iBAAmBE,CACtC,CACF,CACF,CAKA,MAAMT,CAA+D,CAArE,aAAA,CACED,EAAA,KAAQ,eAAe,GAAuC,CAAA,CAK9D,SAASI,EAAyC,CAChD,MAAMC,EAAMD,EAAS,YACfQ,EAAW,KAAK,SAAS,IAAIP,CAAG,GAAK,CAAA,EAC3CO,EAAS,KAAKR,CAAQ,EACtB,KAAK,SAAS,IAAIC,EAAKO,CAAQ,CACjC,CAKA,WAAWC,EAAqBC,EAA4B,CAE1D,MAAMC,GADW,KAAK,SAAS,IAAIF,CAAW,GAAK,CAAA,GACzB,OAAQG,GAAMA,EAAE,eAAiBF,CAAY,EAEnEC,EAAS,OAAS,EACpB,KAAK,SAAS,IAAIF,EAAaE,CAAQ,EAEvC,KAAK,SAAS,OAAOF,CAAW,CAEpC,CAKA,QAAQA,EAA2B,CACjC,KAAK,SAAS,OAAOA,CAAW,CAClC,CAKA,YAAYA,EAAgD,CAC1D,OAAO,KAAK,SAAS,IAAIA,CAAW,GAAK,CAAA,CAC3C,CAKA,gBAAyD,CACvD,OAAO,IAAI,IAAI,KAAK,QAAQ,CAC9B,CACF,CAKO,SAASI,EAAmBlB,EAAkD,CACnF,OAAO,IAAID,EAAiBC,CAAgB,CAC9C,CAKA,MAAMmB,EAAN,MAAMA,CAA2B,CAAjC,aAAA,CAEElB,EAAA,KAAQ,eAAe,GAA0B,CAAA,CAEjD,OAAO,aAA0C,CAC/C,OAAKkB,EAA2B,WAC9BA,EAA2B,SAAW,IAAIA,GAErCA,EAA2B,QACpC,CAEA,SAASL,EAAqBM,EAA6B,CACzD,KAAK,SAAS,IAAIN,EAAaM,CAAO,CACxC,CAEA,WAAWN,EAA2B,CACpC,KAAK,SAAS,OAAOA,CAAW,CAClC,CAEA,WAAWA,EAA+C,CACxD,OAAO,KAAK,SAAS,IAAIA,CAAW,CACtC,CAEA,gBAA4C,CAC1C,OAAO,IAAI,IAAI,KAAK,QAAQ,CAC9B,CAKA,cAAoB,CAClB,MAAMO,EAAY,CAAA,EAElB,SAAW,CAACP,EAAaM,CAAO,IAAK,KAAK,SACxCC,EAAKP,CAAW,EAAI,CAClB,OAASM,EAA6B,UAAA,EAAY,KAClD,SAAWA,EAA6B,YAAA,EAAc,KACtD,gBAAkBA,EAA6B,mBAAA,EAAqB,KACpE,mBAAqBA,EAA6B,sBAAA,EAAwB,KAC1E,SAAWA,EAA6B,YAAA,EAAc,YAAYN,CAAW,CAAA,EAIjF,OAAOO,CACT,CACF,EA5CEpB,EADIkB,EACW,UAAA,EADjB,IAAMG,EAANH,EAkDO,SAASI,EAAqBT,EAAqBM,EAA6B,CACrFE,EAA2B,YAAA,EAAc,SAASR,EAAaM,CAAO,CACxE,CAKO,SAASI,EAAuBV,EAA2B,CAChEQ,EAA2B,YAAA,EAAc,WAAWR,CAAW,CACjE,CAKO,SAASW,EAAgBX,EAA+C,CAC7E,OAAOQ,EAA2B,cAAc,WAAWR,CAAW,CACxE,CAKO,SAASY,GAAiD,CAC/D,OAAOJ,EAA2B,YAAA,EAAc,eAAA,CAClD,CAKO,SAASK,GAAgC,CAC9C,OAAOL,EAA2B,YAAA,EAAc,aAAA,CAClD,CAKO,SAASM,GAAiC,CAC/C,GAAI,OAAO,OAAW,KAAe,QAAQ,IAAI,WAAa,cAAe,CAC3E,MAAMjB,EAAe,OAAe,kBAAoB,CAAA,EAExDA,EAAY,cAAgB,CAC1B,OAAQe,EACR,aAAcC,EACd,WAAYF,CAAA,EAGZ,OAAe,iBAAmBd,EAEpC,QAAQ,IACN,sFAAA,CAEJ,CACF"}