ivue 2.3.0 → 2.5.0

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

@@ -17,6 +17,7 @@ import {
   propsWithDefaults,
   Reactive,
   type ReactiveInstance,
+  definePropTypes,
 } from '../Reactive';
 
 /**
@@ -418,18 +419,18 @@ describe('Reactive()', () => {
         }
       }
       class Mid extends Base {
-        get summary() {
+        override get summary() {
           return computed(() => `(Mid>${super.summary.value})`);
         }
-        get chain() {
+        override get chain() {
           return super.chain + '->Mid';
         }
       }
       class Leaf extends Mid {
-        get summary() {
+        override get summary() {
           return computed(() => `{Leaf>${super.summary.value}}`);
         }
-        get chain() {
+        override get chain() {
           return super.chain + '->Leaf';
         }
       }
@@ -446,7 +447,7 @@ describe('Reactive()', () => {
         }
       }
       class Child extends Base {
-        get val() {
+        override get val() {
           return computed(() => 10 + super.val.value);
         }
       }
@@ -491,13 +492,13 @@ describe('Reactive()', () => {
       }
     }
     class L2 extends L1 {
-      get tag() {
+      override get tag() {
         return computed(() => `L2(${super.tag.value})`);
       }
-      get name() {
+      override get name() {
         return super.name + '>L2';
       }
-      greet() {
+      override greet() {
         return super.greet() + '/L2';
       }
     }
@@ -505,18 +506,18 @@ describe('Reactive()', () => {
       get extra() {
         return ref(5);
       }
-      get tag() {
+      override get tag() {
         return computed(() => `L3[${super.tag.value}]`);
       }
-      get name() {
+      override get name() {
         return super.name + '>L3';
       }
     }
     class L4 extends L3 {
-      get tag() {
+      override get tag() {
         return computed(() => `L4{${super.tag.value}}`);
       }
-      get name() {
+      override get name() {
         return super.name + '>L4';
       }
       // computed in the child aggregating refs declared 3 and 1 levels up
@@ -525,7 +526,7 @@ describe('Reactive()', () => {
           () => (this as any).base.value + (this as any).extra.value,
         );
       }
-      greet() {
+      override greet() {
         return super.greet() + '/L4';
       }
     }
@@ -735,6 +736,64 @@ describe('Reactive()', () => {
       expect(() => instance.$stopEffects()).not.toThrow();
     });
 
+    it('{ reset: false } stops watchers but every cached cell survives', async () => {
+      class Session {
+        get counter() {
+          return ref(0);
+        }
+        get doubled() {
+          return computed(() => (this as any).counter.value * 2);
+        }
+      }
+      const instance: any = new (Reactive(Session))();
+      let observed = 0;
+      instance.$watchEffect(() => {
+        observed = instance.doubled.value; // first-touches the computed IN the scope
+      });
+      const counterCell = instance.counter;
+      const doubledCell = instance.doubled;
+      instance.counter.value = 21;
+      await nextTick();
+      expect(observed).toBe(42);
+
+      instance.$stopEffects({ reset: false });
+
+      // watchers are dead…
+      instance.counter.value = 100;
+      await nextTick();
+      expect(observed).toBe(42);
+      // …but the cells survive with their CURRENT values (no re-init)
+      expect(instance.counter).toBe(counterCell);
+      expect(instance.doubled).toBe(doubledCell);
+      expect(instance.counter.value).toBe(100);
+      // the surviving computed still evaluates (pull-based past scope death)
+      expect(instance.doubled.value).toBe(200);
+
+      // and a SECOND life works: a fresh scope tracks the old cells
+      let observedAgain = 0;
+      instance.$watch(
+        () => instance.doubled.value,
+        (doubledValue: number) => {
+          observedAgain = doubledValue;
+        },
+      );
+      instance.counter.value = 7;
+      await nextTick();
+      expect(observedAgain).toBe(14);
+    });
+
+    it('default call still resets — cells re-initialize after teardown', () => {
+      class Session {
+        get counter() {
+          return ref(0);
+        }
+      }
+      const instance: any = new (Reactive(Session))();
+      instance.counter.value = 41;
+      instance.$stopEffects();
+      expect(instance.counter.value).toBe(0);
+    });
+
     it('$stopEffects is injected only once (idempotent re-Reactive)', () => {
       class Store {
         m() {
@@ -1054,3 +1113,14 @@ describe('$watchEffect (scoped watchEffect)', () => {
     expect(watchRuns).toBe(1); // sibling watcher in the same scope still fires
   });
 });
+
+describe('definePropTypes()', () => {
+  it('returns the same types map (identity, literal-preserving)', () => {
+    const types = definePropTypes({
+      title: { type: String, required: true },
+      size: { type: Number },
+    });
+    expect(types.title.required).toBe(true);
+    expect(types.size.type).toBe(Number);
+  });
+});

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

@@ -49,7 +49,7 @@ describe('Static', () => {
       }
     }
     class $Child extends $Base {
-      static describe() {
+      static override describe() {
         return 'child';
       }
     }
@@ -426,6 +426,65 @@ describe('Static $-cached getters', () => {
     expect(settle()).toBe(70); // inherited method binds to the child, detached
   });
 
+  // invariant: A prototype level is transformed at most once (ivue.invariants.md)
+  it('re-wrapping a subclass never resurrects a parent-bound method through the bind cache', () => {
+    // The double-wrap pattern the manual prescribes: a Static parent, a raw
+    // subclass extending it, and Static() applied again to the subclass.
+    // The parent is READ FIRST, so its bind cache (an own symbol property)
+    // exists when the second wrap walks the chain — that cache must be
+    // invisible to the walk, or the child's methods run with the parent
+    // as receiver.
+    class $Fleet {
+      static get vessels(): string[] {
+        return ['tug'];
+      }
+
+      static roster() {
+        return this.vessels.join(',');
+      }
+    }
+
+    const Fleet = Static($Fleet);
+    expect(Fleet.roster()).toBe('tug'); // parent reads (and caches its bound method) first
+
+    class $HarborFleet extends Fleet {
+      static override get vessels(): string[] {
+        return [...super.vessels, 'ferry'];
+      }
+    }
+    const HarborFleet = Static($HarborFleet);
+
+    expect(HarborFleet.roster()).toBe('tug,ferry'); // the child's override, not the parent's snapshot
+    const roster = HarborFleet.roster;
+    expect(roster()).toBe('tug,ferry'); // detached, still child-bound
+  });
+
+  // invariant: A prototype level is transformed at most once (ivue.invariants.md)
+  it('re-wrapping skips the unregistered bind caches of symbol-keyed methods too', () => {
+    const describeKind = Symbol('describeKind');
+    class $Signal {
+      static get kind(): string {
+        return 'base';
+      }
+
+      static [describeKind]() {
+        return `kind:${this.kind}`;
+      }
+    }
+
+    const Signal = Static($Signal);
+    expect((Signal as any)[describeKind]()).toBe('kind:base'); // parent reads first — unregistered bind cache lands
+
+    class $AlertSignal extends Signal {
+      static override get kind(): string {
+        return 'alert';
+      }
+    }
+    const AlertSignal = Static($AlertSignal);
+
+    expect((AlertSignal as any)[describeKind]()).toBe('kind:alert'); // child receiver, not the parent snapshot
+  });
+
   it('walks the raw inheritance chain — ancestor $-getters cache per receiver', () => {
     class $Base {
       static get scale() {

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

@@ -13,6 +13,7 @@ import {
   ivue,
   propertiesAccessorsMaps,
   propsWithDefaults,
+  definePropTypes,
 } from '../ivue';
 const {
   copyOwnProps,
@@ -76,21 +77,21 @@ class ProductItem extends Item {
 }
 
 class StoreItem extends ProductItem {
-  _productType = iref('store');
-  get productType() {
+  override _productType = iref('store');
+  override get productType() {
     const prefix = super.productFeel ?? '';
     return (prefix ? prefix + ':' : '') + this._productType;
   }
-  set productFeel(value: string) {
+  override set productFeel(value: string) {
     this._productFeel = value;
   }
 }
 
 class RetailStoreItem extends StoreItem {
-  _productType = iref('retail');
+  override _productType = iref('retail');
   /** Do not overwrite productType getter here, on purpose. */
   productHistory = iref([]);
-  get testProperty() {
+  override get testProperty() {
     return this._testProperty;
   }
   calculateSize() {
@@ -1885,3 +1886,14 @@ describe('ivue coverage edge cases', () => {
     expect(cloned.value).toBe(7);
   });
 });
+
+describe('definePropTypes()', () => {
+  it('returns the same types map (identity, literal-preserving)', () => {
+    const types = definePropTypes({
+      title: { type: String, required: true },
+      size: { type: Number },
+    });
+    expect(types.title.required).toBe(true);
+    expect(types.size.type).toBe(Number);
+  });
+});

package/lib/ivue.ts

@@ -1,3 +1,20 @@
+/**
+ * ============================================================
+ *  DEPRECATED — ivue v1 (the reactive-proxy engine)
+ * ============================================================
+ *
+ * This file is the ORIGINAL v1 implementation: `ivue(Class, ...args)`
+ * wraps instances in `reactive()` and converts accessors to computeds.
+ * It is kept in-tree for reference and migration only.
+ *
+ * v2 is `Reactive()` in ./Reactive.ts (the package's main entry) — a
+ * one-time prototype transform: instances stay plain objects, plain
+ * getters cost zero bytes, creation measures 55-253x faster. New code
+ * must never import from this file.
+ *
+ * Migration guide: https://ivue.dev/guide/standard
+ */
+
 import type { ComputedRef, ExtractPropTypes, Ref, ToRef } from 'vue';
 import { computed, markRaw, reactive, ref, shallowRef, toRef } from 'vue';
 import type { Ref as DemiRef } from 'vue-demi';
@@ -113,9 +130,15 @@ export type ExtractEmitTypes<T extends Record<string, any>> =
 
 /**
  * Extract properties as all assigned properties because they have defaults.
+ * Props declared `required: true` are filtered out (they can never carry a
+ * default); declare the types map with a literal-preserving generic call so
+ * the `required: true` literal survives `typeof`.
  */
 export type ExtractPropDefaultTypes<O> = {
-  [K in keyof O]: ValueOf<ExtractPropTypes<O>, K>;
+  [K in keyof O as O[K] extends { required: true } ? never : K]: ValueOf<
+    ExtractPropTypes<O>,
+    K
+  >;
 };
 
 /**
@@ -399,6 +422,8 @@ const getClassPropertiesAccessorsMap = (obj: object): PropsMapValue => {
  *    get getter () { return 'hello world'; }
  * }
  *
+ * @deprecated v1 engine — use `Reactive()` from the main `ivue` entry
+ * instead; see https://ivue.dev/guide/standard for the migration.
  * @param className Any Class
  * @param args Class constructor arguments that you would pass to a `new AnyClass(args...)`
  * @returns {IVue<T>}
@@ -760,6 +785,14 @@ export const isClass = (val: any): boolean => {
  * @param typedProps Props declared in defineComponent() style with type and possibly required declared, but without default
  * @returns Props declared in defineComponent() style with all properties having default property declared.
  */
+/**
+ * Identity helper for a prop-TYPES map: generic inference preserves the
+ * `required: true` literal that a bare object const widens to `boolean`,
+ * which ExtractPropDefaultTypes' required-key filter depends on.
+ */
+export const definePropTypes = <T extends VuePropsObject>(types: T): T =>
+  types;
+
 export const propsWithDefaults = <T extends VuePropsObject>(
   defaults: Record<string, any>,
   typedProps: T,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ivue",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "Infinite Vue – Class Based Architecture for Vue 3",
   "type": "module",
   "exports": {
@@ -14,12 +14,16 @@
       "import": "./dist/extras.es.js",
       "require": "./dist/extras.cjs"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./skills/*": "./skills/*"
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.es.js",
   "types": "./dist/index.d.ts",
   "scripts": {
+    "gate": "vite-node skills/ivue/ivue-standards-check.ts --",
+    "gate:house": "vite-node skills/ivue/ivue-house-gate.ts --",
+    "gate:newsletter": "vite-node skills/ivue/ivue-generator-standard.ts -- --source-root newsletter --skip-list skills/ivue/ivue-standards-skip.json --test-glob 'newsletter/src/**/*.test.ts'",
     "dev": "vite demo --host",
     "dev:demo": "vite demo --host",
     "dev:flyweight": "vite examples/playground --port 5181 --host",
@@ -39,7 +43,7 @@
     "cypress:headed": "cypress run --component --browser chrome --headed --no-exit",
     "build": "tsc --version;tsc --p ./tsconfig.json && vite build",
     "build:demo": "tsc --p ./tsconfig.json && vite build demo",
-    "build:docs": "npm run sync:examples && npm run sync:releases && npm run sync:blog-index && npm --prefix docs_v2 run build && npm run check:links && node docs_v2/scripts/check-related-posts.mjs",
+    "build:docs": "npm run sync:examples && npm run sync:releases && npm run sync:blog-index && node docs_v2/scripts/rss-generator.mjs && npm --prefix docs_v2 run build && npm run check:links && node docs_v2/scripts/check-related-posts.mjs",
     "sync:releases": "node docs_v2/scripts/releases-page-generator.mjs",
     "sync:blog-index": "node docs_v2/scripts/blog-index-generator.mjs",
     "check:links": "node docs_v2/scripts/check-links.mjs",
@@ -47,6 +51,7 @@
     "render:form-header": "node docs_v2/scripts/brand-image-generator.mjs form-header",
     "render:banner": "node docs_v2/scripts/brand-image-generator.mjs blog",
     "render:diagram": "node docs_v2/scripts/brand-image-generator.mjs diagram",
+    "render:page-og": "node docs_v2/scripts/page-og-generator.mjs",
     "render:embeds": "node docs_v2/scripts/blog-embed-shots.mjs",
     "render:code-shots": "node docs_v2/scripts/blog-code-shots.mjs",
     "sync:blog-dates": "node docs_v2/scripts/blog-dates-generator.mjs",