ivue 2.2.2 → 2.4.0

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

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest';
+import { LazyShared } from '../LazyShared';
+import { Static } from '../Static';
+
+describe('LazyShared', () => {
+  it('evaluates nothing at definition, constructs once, shares the result', () => {
+    let constructionCount = 0;
+    const cell = new LazyShared(() => {
+      constructionCount += 1;
+      return { count: constructionCount };
+    });
+    expect(constructionCount).toBe(0); // load-safe: the thunk is inert
+    expect(cell.value).toBe(cell.value);
+    expect(constructionCount).toBe(1);
+  });
+
+  it('every receiver converges on the ONE singleton — forking the access path is harmless', () => {
+    let constructionCount = 0;
+    class $Owner {
+      protected static readonly sharedStore = new LazyShared(() => {
+        constructionCount += 1;
+        return new Map<string, number>();
+      });
+      static store(): Map<string, number> {
+        return this.sharedStore.value;
+      }
+    }
+    class $SubReceiver extends $Owner {}
+    $Owner.store().set('planted', 7);
+    expect($SubReceiver.store().get('planted')).toBe(7);
+    expect($SubReceiver.store()).toBe($Owner.store());
+    expect(constructionCount).toBe(1);
+  });
+
+  it('even a per-receiver $-cache over the cell returns the same singleton', () => {
+    // The registry-fork trap: Static()'s $-getters cache per receiver,
+    // so parent and subclass each run the getter body once. With the
+    // body reading a LazyShared cell, both receivers cache the SAME
+    // constructed value — the fork exists only in the access path.
+    let constructionCount = 0;
+    class $Registry {
+      protected static readonly sharedEntries = new LazyShared(() => {
+        constructionCount += 1;
+        return new Map<string, number>();
+      });
+      static get $entries(): Map<string, number> {
+        return this.sharedEntries.value;
+      }
+    }
+    const Registry = Static($Registry);
+    class $SubRegistry extends Registry {}
+    const SubRegistry = Static($SubRegistry);
+    Registry.$entries.set('planted', 7);
+    expect(SubRegistry.$entries).toBe(Registry.$entries);
+    expect(SubRegistry.$entries.get('planted')).toBe(7);
+    expect(constructionCount).toBe(1);
+  });
+
+  it('reset drops the value and the next read constructs again', () => {
+    let constructionCount = 0;
+    const cell = new LazyShared(() => (constructionCount += 1));
+    expect(cell.value).toBe(1);
+    cell.reset();
+    expect(cell.value).toBe(2);
+  });
+
+  it('a thunk cycle throws a named error and leaves the cell retryable', () => {
+    const cellA = new LazyShared((): number => cellB.value + 1);
+    const cellB = new LazyShared((): number => cellA.value + 1);
+    expect(() => cellA.value).toThrow('LazyShared thunk cycle');
+    // not poisoned: break the cycle and the same cell constructs fine
+    let repaired = 0;
+    const cellC = new LazyShared((): number => (repaired += 1));
+    expect(cellC.value).toBe(1);
+    // the failed cell itself retries once its dependency resolves
+    expect(() => cellB.value).toThrow('LazyShared thunk cycle');
+  });
+
+  it('a throwing thunk does not poison the cell — the next read retries', () => {
+    let attempts = 0;
+    const cell = new LazyShared(() => {
+      attempts += 1;
+      if (attempts === 1) throw new Error('backend not ready');
+      return 'ready';
+    });
+    expect(() => cell.value).toThrow('backend not ready');
+    expect(cell.value).toBe('ready');
+    expect(attempts).toBe(2);
+  });
+});

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

@@ -735,6 +735,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() {

package/lib/extras.ts

@@ -7,3 +7,4 @@
  *   import { Static } from 'ivue/extras';
  */
 export { Static, type ClassConstructor } from './Static';
+export { LazyShared } from './LazyShared';

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';
@@ -399,6 +416,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>}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ivue",
-  "version": "2.2.2",
+  "version": "2.4.0",
   "description": "Infinite Vue – Class Based Architecture for Vue 3",
   "type": "module",
   "exports": {
@@ -29,6 +29,8 @@
     "measure:formula": "node demo/formula/measure.mjs",
     "measure:grid": "node demo/grid/measure.mjs",
     "dev:docs": "npm --prefix docs_v2 run dev -- --port 5174",
+    "admin": "vite newsletter/dashboard --host",
+    "build:admin": "vite build newsletter/dashboard",
     "test": "vitest --coverage.enabled=true --reporter=verbose --ui",
     "coverage": "vitest run --coverage",
     "bench": "vitest bench --run",
@@ -37,11 +39,17 @@
     "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 --prefix docs_v2 run build && npm run check:links",
+    "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",
+    "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",
     "render:og": "node docs_v2/scripts/brand-image-generator.mjs og",
     "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",
     "preview:demo": "npm run build:demo && vite preview demo --host",
     "preview:docs": "npm --prefix docs_v2 run preview",
@@ -51,7 +59,8 @@
     "sync:examples": "node -e \"require('fs').copyFileSync('lib/Reactive.ts','examples/playground/src/ivue.ts')\"",
     "dev:playground": "vite examples/playground --host",
     "build:playground": "vite build examples/playground",
-    "preview:playground": "vite preview examples/playground --host"
+    "preview:playground": "vite preview examples/playground --host",
+    "rename:blog-slug": "node docs_v2/scripts/rename-blog-slug.mjs"
   },
   "peerDependencies": {
     "vue": "^3.2.0",