ivue 2.2.0 → 2.2.1

package/dist/Reactive.d.ts

@@ -87,7 +87,9 @@ export declare type ReactiveInstance<T> = T & WritableGetters<T> & {
     /** Stop the instance's effect scope and drop cached cells. */
     $stopEffects: () => void;
 };
-export declare type ReactiveClass<C extends new (...args: any) => any> = new (...args: ConstructorParameters<C>) => ReactiveInstance<InstanceType<C>>;
+export declare type ReactiveClass<C extends new (...args: any) => any> = {
+    [Key in keyof C]: C[Key];
+} & (new (...args: ConstructorParameters<C>) => ReactiveInstance<InstanceType<C>>);
 /**
  * Component-authoring type utilities (types only — erased at build time).
  * These complement `propsWithDefaults` for the params/defaults component

package/dist/Static.d.ts

@@ -8,15 +8,26 @@
  *
  * Get-only static accessors whose name starts with `$` become
  * compute-once-per-receiver caches: the getter body runs on first read
- * through a given class, its (shallowly frozen) result is stored under a
- * symbol OWN property of that receiver, and later reads return the stored
- * value. The `Object.hasOwn` guard never walks the prototype chain, so a
- * parent's cache can never shadow a subclass — each class in a hierarchy
- * derives through its own overrides on its own first read, in ANY read
- * order. The `$` prefix IS the API: a static getter that must stay live
- * (a knob for subclasses to pinch, a fresh-per-read value) must not use
- * it. Cached values are frozen shallowly — cache-and-freeze or
- * return-fresh, never cache-mutable.
+ * through a given class, its result is stored under a symbol OWN property
+ * of that receiver, and later reads return the stored value. The
+ * `Object.hasOwn` guard never walks the prototype chain, so a parent's
+ * cache can never shadow a subclass — each class in a hierarchy derives
+ * through its own overrides on its own first read, in ANY read order.
+ * The `$` prefix IS the API: it promises STABLE IDENTITY per receiver,
+ * nothing more — whether the cached value is then treated as immutable
+ * config or as a mutable memo table is the author's design. A static
+ * getter that must stay live (a knob for subclasses to pinch, a
+ * fresh-per-read value) must not use the prefix.
+ *
+ * Method binding uses the same per-receiver symbol discipline: the bound
+ * function is cached under a symbol own property, never under the method
+ * name — so a parent-first read can never install a parent-bound method
+ * where a subclass's chain lookup would find it.
+ *
+ * `$` semantics are GRANTED BY the transform: a raw class, a raw
+ * subclass, or a class only passed through `Reactive()` keeps native
+ * getter behavior. A class that needs instance reactivity AND static
+ * `$`-caches composes the transforms: `Static(Reactive($Class))`.
  *
  * This is the namespace pattern's backend adapter: canonical namespace +
  * mutable `Class` slot + late reads, for STATELESS capability classes (a

package/dist/extras.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"}),exports.Static=function(i){const o=class extends i{},s=new Set;for(let n=i;n!==Function.prototype;n=Object.getPrototypeOf(n))for(const e of Reflect.ownKeys(n)){if(s.has(e))continue;s.add(e);const t=Object.getOwnPropertyDescriptor(n,e);if(typeof t.value=="function"){const c=t.value;Object.defineProperty(o,e,{configurable:!0,enumerable:t.enumerable,get(){const r=c.bind(this);return Object.defineProperty(this,e,{...t,value:r}),r}})}else if(t.get&&!t.set&&typeof e=="string"&&e.startsWith("$")){const c=t.get,r=Symbol.for(`ivue.staticCache.${e}`);Object.defineProperty(o,e,{configurable:!0,enumerable:t.enumerable,get(){return Object.hasOwn(this,r)||Object.defineProperty(this,r,{configurable:!0,value:Object.freeze(c.call(this))}),this[r]}})}}return o};
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=Object.hasOwn;exports.Static=function(c){const r=class extends c{},s=new Set;for(let o=c;o!==Function.prototype;o=Object.getPrototypeOf(o))for(const e of Reflect.ownKeys(o)){if(s.has(e))continue;s.add(e);const t=Object.getOwnPropertyDescriptor(o,e);if(typeof t.value=="function"){const i=t.value,n=typeof e=="string"?Symbol.for(`ivue.staticBound.${e}`):Symbol("ivue.staticBound");Object.defineProperty(r,e,{configurable:!0,enumerable:t.enumerable,get(){return u(this,n)||Object.defineProperty(this,n,{configurable:!0,value:i.bind(this)}),this[n]}})}else if(t.get&&!t.set&&typeof e=="string"&&e.startsWith("$")){const i=t.get,n=Symbol.for(`ivue.staticCache.${e}`);Object.defineProperty(r,e,{configurable:!0,enumerable:t.enumerable,get(){return u(this,n)||Object.defineProperty(this,n,{configurable:!0,value:i.call(this)}),this[n]}})}}return r};

package/dist/extras.es.js

@@ -1,27 +1,27 @@
-function a(i) {
-  const o = class extends i {
-  }, s = /* @__PURE__ */ new Set();
-  for (let r = i; r !== Function.prototype; r = Object.getPrototypeOf(r))
-    for (const e of Reflect.ownKeys(r)) {
-      if (s.has(e))
+const a = Object.hasOwn;
+function u(s) {
+  const r = class extends s {
+  }, c = /* @__PURE__ */ new Set();
+  for (let n = s; n !== Function.prototype; n = Object.getPrototypeOf(n))
+    for (const e of Reflect.ownKeys(n)) {
+      if (c.has(e))
         continue;
-      s.add(e);
-      const t = Object.getOwnPropertyDescriptor(r, e);
+      c.add(e);
+      const t = Object.getOwnPropertyDescriptor(n, e);
       if (typeof t.value == "function") {
-        const c = t.value;
-        Object.defineProperty(o, e, { configurable: !0, enumerable: t.enumerable, get() {
-          const n = c.bind(this);
-          return Object.defineProperty(this, e, { ...t, value: n }), n;
+        const i = t.value, o = typeof e == "string" ? Symbol.for(`ivue.staticBound.${e}`) : Symbol("ivue.staticBound");
+        Object.defineProperty(r, e, { configurable: !0, enumerable: t.enumerable, get() {
+          return a(this, o) || Object.defineProperty(this, o, { configurable: !0, value: i.bind(this) }), this[o];
         } });
       } else if (t.get && !t.set && typeof e == "string" && e.startsWith("$")) {
-        const c = t.get, n = Symbol.for(`ivue.staticCache.${e}`);
-        Object.defineProperty(o, e, { configurable: !0, enumerable: t.enumerable, get() {
-          return Object.hasOwn(this, n) || Object.defineProperty(this, n, { configurable: !0, value: Object.freeze(c.call(this)) }), this[n];
+        const i = t.get, o = Symbol.for(`ivue.staticCache.${e}`);
+        Object.defineProperty(r, e, { configurable: !0, enumerable: t.enumerable, get() {
+          return a(this, o) || Object.defineProperty(this, o, { configurable: !0, value: i.call(this) }), this[o];
         } });
       }
     }
-  return o;
+  return r;
 }
 export {
-  a as Static
+  u as Static
 };

package/lib/Reactive.ts

@@ -434,9 +434,9 @@ export type ReactiveInstance<T> = T &
     $stopEffects: () => void;
   };
 
-export type ReactiveClass<C extends new (...args: any) => any> = new (
-  ...args: ConstructorParameters<C>
-) => ReactiveInstance<InstanceType<C>>;
+export type ReactiveClass<C extends new (...args: any) => any> = {
+  [Key in keyof C]: C[Key];
+} & (new (...args: ConstructorParameters<C>) => ReactiveInstance<InstanceType<C>>);
 
 /**
  * Component-authoring type utilities (types only — erased at build time).

package/lib/Static.ts

@@ -8,15 +8,26 @@
  *
  * Get-only static accessors whose name starts with `$` become
  * compute-once-per-receiver caches: the getter body runs on first read
- * through a given class, its (shallowly frozen) result is stored under a
- * symbol OWN property of that receiver, and later reads return the stored
- * value. The `Object.hasOwn` guard never walks the prototype chain, so a
- * parent's cache can never shadow a subclass — each class in a hierarchy
- * derives through its own overrides on its own first read, in ANY read
- * order. The `$` prefix IS the API: a static getter that must stay live
- * (a knob for subclasses to pinch, a fresh-per-read value) must not use
- * it. Cached values are frozen shallowly — cache-and-freeze or
- * return-fresh, never cache-mutable.
+ * through a given class, its result is stored under a symbol OWN property
+ * of that receiver, and later reads return the stored value. The
+ * `Object.hasOwn` guard never walks the prototype chain, so a parent's
+ * cache can never shadow a subclass — each class in a hierarchy derives
+ * through its own overrides on its own first read, in ANY read order.
+ * The `$` prefix IS the API: it promises STABLE IDENTITY per receiver,
+ * nothing more — whether the cached value is then treated as immutable
+ * config or as a mutable memo table is the author's design. A static
+ * getter that must stay live (a knob for subclasses to pinch, a
+ * fresh-per-read value) must not use the prefix.
+ *
+ * Method binding uses the same per-receiver symbol discipline: the bound
+ * function is cached under a symbol own property, never under the method
+ * name — so a parent-first read can never install a parent-bound method
+ * where a subclass's chain lookup would find it.
+ *
+ * `$` semantics are GRANTED BY the transform: a raw class, a raw
+ * subclass, or a class only passed through `Reactive()` keeps native
+ * getter behavior. A class that needs instance reactivity AND static
+ * `$`-caches composes the transforms: `Static(Reactive($Class))`.
  *
  * This is the namespace pattern's backend adapter: canonical namespace +
  * mutable `Class` slot + late reads, for STATELESS capability classes (a
@@ -29,6 +40,8 @@
  */
 export type ClassConstructor = new (...arguments_: any[]) => any;
 
+const hasOwn = Object.hasOwn;
+
 export function Static<Class extends ClassConstructor>(targetClass: Class): Class {
   const SelectedClass = class extends targetClass {};
   const visitedKeys = new Set<PropertyKey>();
@@ -46,14 +59,22 @@ export function Static<Class extends ClassConstructor>(targetClass: Class): Clas
 
       if (typeof descriptor.value === 'function') {
         const method = descriptor.value;
+        const bindKey =
+          typeof key === 'string'
+            ? Symbol.for(`ivue.staticBound.${key}`)
+            : Symbol('ivue.staticBound');
 
         Object.defineProperty(SelectedClass, key, {
           configurable: true,
           enumerable: descriptor.enumerable,
-          get(this: ClassConstructor) {
-            const boundMethod = method.bind(this);
-            Object.defineProperty(this, key, { ...descriptor, value: boundMethod });
-            return boundMethod;
+          get(this: any) {
+            if (!hasOwn(this, bindKey)) {
+              Object.defineProperty(this, bindKey, {
+                configurable: true,
+                value: method.bind(this),
+              });
+            }
+            return this[bindKey];
           },
         });
       } else if (
@@ -69,10 +90,10 @@ export function Static<Class extends ClassConstructor>(targetClass: Class): Clas
           configurable: true,
           enumerable: descriptor.enumerable,
           get(this: any) {
-            if (!Object.hasOwn(this, cacheKey)) {
+            if (!hasOwn(this, cacheKey)) {
               Object.defineProperty(this, cacheKey, {
                 configurable: true,
-                value: Object.freeze(getter.call(this)),
+                value: getter.call(this),
               });
             }
             return this[cacheKey];

package/lib/__tests__/Static.vitest.spec.ts

@@ -1,4 +1,6 @@
+import { ref } from 'vue';
 import { describe, expect, it } from 'vitest';
+import { Reactive } from '../Reactive';
 import { Static } from '../Static';
 
 describe('Static', () => {
@@ -81,6 +83,23 @@ describe('Static', () => {
     expect(Config.resolve('/path')).toBe('https://example.test/path');
   });
 
+  it('binds symbol-keyed static methods with the same discipline', () => {
+    const describeKind = Symbol('describeKind');
+
+    class $Shape {
+      static kind = 'circle';
+      static [describeKind]() {
+        return `kind:${this.kind}`;
+      }
+    }
+
+    const Shape = Static($Shape);
+    const described = (Shape as any)[describeKind];
+
+    expect((Shape as any)[describeKind]).toBe(described); // identity-stable
+    expect(described()).toBe('kind:circle'); // bound through detachment
+  });
+
   it('binds `this` to the wrapped class, so statics compose', () => {
     class $Report {
       static header() {
@@ -166,21 +185,26 @@ describe('Static $-cached getters', () => {
     expect(computeRuns).toBe(2); // once per receiver, never shared
   });
 
-  it('freezes cached values — mutation throws instead of corrupting', () => {
-    class $Config {
-      static get $defaults() {
-        return { width: 80 };
+  it('promises stable identity, not immutability — memo tables mutate freely', () => {
+    class $Wrap {
+      static get $memo() {
+        return new Map<string, number>();
+      }
+      static get $state() {
+        return { frame: 0, quiescent: false };
       }
     }
 
-    const Config = Static($Config);
-    const defaults = Config.$defaults;
+    const Wrap = Static($Wrap);
 
-    expect(Object.isFrozen(defaults)).toBe(true);
-    expect(() => {
-      (defaults as any).width = 120;
-    }).toThrow(TypeError);
-    expect(Config.$defaults.width).toBe(80);
+    // a cached Map used as a per-class memo table — the dominant real pattern
+    Wrap.$memo.set('row', 42);
+    expect(Wrap.$memo.get('row')).toBe(42); // same table, mutation retained
+
+    // a cached plain object used as deliberate mutable state
+    Object.assign(Wrap.$state, { frame: 7, quiescent: true });
+    expect(Wrap.$state.frame).toBe(7);
+    expect(Wrap.$state).toBe(Wrap.$state); // identity stable throughout
   });
 
   it('caches primitive results too', () => {
@@ -257,6 +281,87 @@ describe('Static $-cached getters', () => {
     expect(Theme.$accent).toBe('blue');
   });
 
+  it('method binding is order-correct: parent read first, child dispatch intact', () => {
+    class $Render {
+      static get glyph() {
+        return '-'; // a knob subclasses pinch
+      }
+      static paint() {
+        return this.glyph.repeat(3);
+      }
+    }
+
+    const Render = Static($Render);
+    class DottedRender extends Render {
+      static override get glyph() {
+        return '.';
+      }
+    }
+
+    // PARENT reads first — the named-own-property shape poisoned this order
+    const parentPaint = Render.paint;
+    expect(parentPaint()).toBe('---');
+    expect(DottedRender.paint()).toBe('...'); // child binds itself, chain not shadowed
+    expect(DottedRender.paint).toBe(DottedRender.paint); // still identity-stable
+    expect(Render.paint).toBe(parentPaint);
+  });
+
+  it('method binding is order-correct: child read first, parent unaffected', () => {
+    class $Render {
+      static get glyph() {
+        return '-';
+      }
+      static paint() {
+        return this.glyph.repeat(2);
+      }
+    }
+
+    const Render = Static($Render);
+    class DottedRender extends Render {
+      static override get glyph() {
+        return '.';
+      }
+    }
+
+    expect(DottedRender.paint()).toBe('..');
+    expect(Render.paint()).toBe('--');
+  });
+
+  it('composes with Reactive(): Static(Reactive($Class)) grants both contracts', () => {
+    let derivations = 0;
+
+    class $Channel {
+      get status() {
+        return ref('idle');
+      }
+      announce() {
+        return `channel:${this.status.value}`;
+      }
+      static get $defaults() {
+        derivations++;
+        return { retries: 3 };
+      }
+      static open() {
+        return this.$defaults.retries;
+      }
+    }
+
+    const Channel = Static(Reactive($Channel));
+
+    // instance side: Reactive semantics intact through the Static subclass
+    const channel: any = new Channel();
+    const statusCell = channel.status;
+    expect(statusCell.value).toBe('idle');
+    expect(channel.status).toBe(statusCell); // cached ref cell
+    expect(channel.announce()).toBe('channel:idle');
+
+    // static side: $-cache + bound methods from Static
+    expect(Channel.$defaults).toBe(Channel.$defaults);
+    expect(derivations).toBe(1);
+    const open = Channel.open;
+    expect(open()).toBe(3); // detached, still bound
+  });
+
   it('walks the raw inheritance chain — ancestor $-getters cache per receiver', () => {
     class $Base {
       static get scale() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ivue",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Infinite Vue – Class Based Architecture for Vue 3",
   "type": "module",
   "exports": {