ivue 1.6.1 → 2.0.0

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

@@ -0,0 +1,182 @@
+import { reactive, ref } from 'vue';
+import { describe, expect, it, vi } from 'vitest';
+import { Reactive } from '../Reactive';
+import { Kernel } from '../kernel';
+
+describe('Reactive adversarial boundaries', () => {
+  it('richer cleanup composes as an ordinary method calling $stopEffects', () => {
+    const observed: number[] = [];
+    let closed = 0;
+
+    class $Store {
+      get count() {
+        return ref(0);
+      }
+
+      // the composition pattern: no reserved names, no auto-calls —
+      // the class's own dispose() does its work, then resets the engine
+      dispose() {
+        this.closeSocket();
+        (this as any).$stopEffects();
+      }
+
+      closeSocket() {
+        closed++;
+      }
+    }
+
+    const Store = Reactive($Store);
+    const store: any = new Store();
+    const originalCount = store.count;
+    store.$watch(
+      () => store.count.value,
+      (count: number) => observed.push(count),
+      { flush: 'sync' },
+    );
+
+    originalCount.value = 1;
+    expect(observed).toEqual([1]);
+
+    store.dispose();
+
+    expect(closed).toBe(1);
+    originalCount.value = 2;
+    expect(observed).toEqual([1]); // watcher dead
+    expect(store.count).not.toBe(originalCount); // cells reset
+  });
+
+  it('teardown clears only engine cache keys — consumer symbols survive', () => {
+    const consumerSymbol = Symbol('consumer-metadata');
+
+    class $Parent {
+      get inherited() {
+        return ref('parent');
+      }
+    }
+
+    class $Child extends $Parent {
+      get own() {
+        return ref('child');
+      }
+
+      grow() {
+        return this.own.value;
+      }
+    }
+
+    const Child = Reactive($Child);
+    const child: any = new Child();
+
+    // materialize cells on BOTH prototype layers + a bound method
+    const inheritedCell = child.inherited;
+    const ownCell = child.own;
+    const boundGrow = child.grow;
+    // a symbol the engine did NOT create — foreign metadata on the instance
+    child[consumerSymbol] = 'must survive';
+
+    child.$stopEffects();
+
+    // engine cells across the whole chain are gone: fresh identities
+    expect(child.inherited).not.toBe(inheritedCell);
+    expect(child.own).not.toBe(ownCell);
+    expect(child.grow).not.toBe(boundGrow);
+    // the consumer's symbol is untouched
+    expect(child[consumerSymbol]).toBe('must survive');
+  });
+
+  it('can allocate a fresh watcher scope after teardown', () => {
+    class $Store {
+      get count() {
+        return ref(0);
+      }
+    }
+
+    const Store = Reactive($Store);
+    const store: any = new Store();
+    const firstObserved = vi.fn();
+    store.$watch(() => store.count.value, firstObserved, { flush: 'sync' });
+    store.count.value = 1;
+    store.$stopEffects();
+
+    const secondObserved = vi.fn();
+    store.$watch(() => store.count.value, secondObserved, { flush: 'sync' });
+    store.count.value = 2;
+
+    expect(firstObserved).toHaveBeenCalledTimes(1);
+    expect(secondObserved).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not poison a lazy ref cache when its factory throws once', () => {
+    let attempts = 0;
+
+    class $Store {
+      get state() {
+        attempts++;
+        if (attempts === 1) throw new Error('dependency is not ready');
+        return ref(7);
+      }
+    }
+
+    const Store = Reactive($Store);
+    const store = new Store();
+
+    expect(() => store.state).toThrow('dependency is not ready');
+    const recovered = store.state;
+    expect(recovered.value).toBe(7);
+    expect(store.state).toBe(recovered);
+    expect(attempts).toBe(2);
+  });
+
+  it('caches an undefined $-singleton result instead of rerunning it', () => {
+    const factory = vi.fn(() => undefined);
+
+    class $Store {
+      get $optionalService() {
+        return factory();
+      }
+    }
+
+    const Store = Reactive($Store);
+    const store = new Store();
+
+    expect(store.$optionalService).toBeUndefined();
+    expect(store.$optionalService).toBeUndefined();
+    expect(factory).toHaveBeenCalledTimes(1);
+  });
+
+  it('tears down the raw instance when invoked through a Vue proxy', () => {
+    const observed = vi.fn();
+
+    class $Store {
+      get count() {
+        return ref(0);
+      }
+    }
+
+    const Store = Reactive($Store);
+    const rawStore: any = new Store();
+    const proxiedStore: any = reactive(rawStore);
+    const originalCount = rawStore.count;
+    proxiedStore.$watch(() => rawStore.count.value, observed, { flush: 'sync' });
+
+    originalCount.value = 1;
+    proxiedStore.$stopEffects();
+    originalCount.value = 2;
+
+    expect(observed).toHaveBeenCalledTimes(1);
+    expect(rawStore.count).not.toBe(originalCount);
+  });
+});
+
+describe('Kernel adversarial values', () => {
+  it('preserves stored falsy values instead of taking the fallback', () => {
+    const kernel = new Kernel();
+    kernel.set('zero', 0);
+    kernel.set('false', false);
+    kernel.set('empty', '');
+
+    expect(kernel.get('zero', 1)).toBe(0);
+    expect(kernel.get('false', true)).toBe(false);
+    expect(kernel.get('empty', 'fallback')).toBe('');
+  });
+});

package/lib/__tests__/coverage-completion.vitest.spec.ts

@@ -0,0 +1,24 @@
+/**
+ * Coverage completion for the package entry and Kernel container.
+ */
+import { describe, expect, it } from 'vitest';
+import * as packageEntry from '../index';
+import { Kernel, kernel } from '../kernel';
+
+describe('package entry (index.ts)', () => {
+  it('re-exports the engine surface', () => {
+    expect(typeof packageEntry.Reactive).toBe('function');
+  });
+});
+
+describe('Kernel', () => {
+  it('sets, gets, falls back, clears', () => {
+    const container = new Kernel();
+    container.set('answer', 42);
+    expect(container.get('answer', 0)).toBe(42);
+    expect(container.get('missing', 'fallback')).toBe('fallback');
+    container.clear();
+    expect(container.get('answer', 0)).toBe(0);
+    expect(kernel).toBeInstanceOf(Kernel);
+  });
+});

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

@@ -955,36 +955,36 @@ describe('ivue', () => {
     });
 
     it('mirrors default flags for class accessors: enumerable=false, configurable=true', () => {
-      const inst = ivue(Flags);
-      const d = Object.getOwnPropertyDescriptor(inst, 'hidden');
+      const instance = ivue(Flags);
+      const d = Object.getOwnPropertyDescriptor(instance, 'hidden');
 
       expect(d?.enumerable).toBe(false);
       expect(d?.configurable).toBe(true);
-      expect(isEnumerable(inst, 'hidden')).toBe(false);
+      expect(isEnumerable(instance, 'hidden')).toBe(false);
     });
 
     it('preserves enumerable=true from prototype on the reactive instance', () => {
-      const inst = ivue(Flags);
-      const d = Object.getOwnPropertyDescriptor(inst, 'visible');
+      const instance = ivue(Flags);
+      const d = Object.getOwnPropertyDescriptor(instance, 'visible');
 
       expect(d?.enumerable).toBe(true);
-      expect(isEnumerable(inst, 'visible')).toBe(true);
+      expect(isEnumerable(instance, 'visible')).toBe(true);
 
       // sanity check: hidden is not in keys; visible is
-      const keys = Object.keys(inst);
+      const keys = Object.keys(instance);
       expect(keys.includes('visible')).toBe(true);
       expect(keys.includes('hidden')).toBe(false);
     });
 
     it('preserves configurable=false from prototype (cannot redefine)', () => {
-      const inst = ivue(Flags);
-      const d = Object.getOwnPropertyDescriptor(inst, 'locked');
+      const instance = ivue(Flags);
+      const d = Object.getOwnPropertyDescriptor(instance, 'locked');
 
       expect(d?.configurable).toBe(false);
 
       // Attempting to redefine should throw a TypeError
       expect(() =>
-        Object.defineProperty(inst, 'locked', {
+        Object.defineProperty(instance, 'locked', {
           get() {
             return 99;
           },
@@ -993,14 +993,14 @@ describe('ivue', () => {
     });
 
     it('configurable=true allows redefining accessor on the reactive instance', () => {
-      const inst = ivue(Flags);
+      const instance = ivue(Flags);
 
       // Before redefine
       // @ts-expect-error anyway
-      expect(inst.visible).toBe(2);
+      expect(instance.visible).toBe(2);
 
       // Redefine should succeed (configurable=true)
-      Object.defineProperty(inst, 'visible', {
+      Object.defineProperty(instance, 'visible', {
         get() {
           return 42;
         },
@@ -1009,10 +1009,10 @@ describe('ivue', () => {
       });
 
       // @ts-expect-error anyway
-      expect(inst.visible).toBe(42);
+      expect(instance.visible).toBe(42);
 
       // And flags remain as set on redefinition
-      const d = Object.getOwnPropertyDescriptor(inst, 'visible');
+      const d = Object.getOwnPropertyDescriptor(instance, 'visible');
       expect(d?.enumerable).toBe(true);
       expect(d?.configurable).toBe(true);
     });
@@ -1033,13 +1033,13 @@ describe('ivue', () => {
         x = iref(7); // normal data
       }
 
-      const inst = ivue(WithSymbol);
+      const instance = ivue(WithSymbol);
 
       // sanity: Vue proxy still has the symbol (we won’t surface it)
-      expect(inst[S]).toBe(123);
+      expect(instance[S]).toBe(123);
 
       // our property collector should not list symbols
-      const { allProps } = getClassPropertiesAccessorsMap(inst);
+      const { allProps } = getClassPropertiesAccessorsMap(instance);
       // only string keys
       for (const k of allProps.keys()) {
         expect(typeof k).toBe('string');
@@ -1048,7 +1048,7 @@ describe('ivue', () => {
       expect(allProps.has('method')).toBe(false);
 
       // toRefs() should not expose symbol-backed fields
-      const r = inst.toRefs();
+      const r = instance.toRefs();
       expect('x' in r).toBe(true);
       expect('method' in r).toBe(false);
       expect(Object.getOwnPropertySymbols(r).length).toBe(0);
@@ -1828,3 +1828,60 @@ describe('ivue', () => {
     });
   });
 });
+
+describe('ivue coverage edge cases', () => {
+  it('propsWithDefaults skips a required prop even when a default exists', () => {
+    const typed = {
+      a: { type: String, required: true },
+      b: { type: Number },
+    };
+    const out = propsWithDefaults({ a: 'ignored', b: 2 }, { ...typed }) as Record<
+      string,
+      any
+    >;
+    // required → the `if (typed.required) continue` branch is taken
+    expect('default' in out.a).toBe(false);
+    expect(out.b.default).toBe(2);
+  });
+
+  it('ivueDisableReactivity preserves BOTH getter and setter for an accessor', () => {
+    class WithRW {
+      static ivueDisableReactivity = new Set<keyof WithRW>(['rw']);
+      _v = 1;
+      get rw() {
+        return this._v;
+      }
+      set rw(value: number) {
+        this._v = value;
+      }
+    }
+
+    // ivue() path: descriptor has get AND set → both `?.bind(vue)` branches run
+    const a = ivue(WithRW);
+    expect(a.rw).toBe(1);
+    a.rw = 5;
+    expect(a.rw).toBe(5);
+
+    // clone() path exercises the same branch in ivueClone()
+    const b = a.clone();
+    expect(b.rw).toBe(5);
+    b.rw = 9;
+    expect(b.rw).toBe(9);
+    expect(a.rw).toBe(5); // isolation
+  });
+
+  it('deepClone tolerates a deepCloneArgs entry mapped to undefined (uses [])', () => {
+    class Svc {
+      value = 1;
+      init(_isClone?: boolean, v = 7) {
+        this.value = v;
+      }
+    }
+    const svc = ivue(Svc);
+    // has(Svc) === true but get(Svc) === undefined → the `?? []` fallback runs
+    const deepCloneArgs = new Map<any, any[]>([[Svc, undefined as any]]);
+    const cloned = deepClone(svc, deepCloneArgs);
+    // clone() called with no args → init(true) default → value = 7
+    expect(cloned.value).toBe(7);
+  });
+});

package/lib/index.ts

@@ -1,2 +1 @@
-export * from './ivue';
-// export * from './Reactive';
+export * from './Reactive';

package/package.json

@@ -1,32 +1,52 @@
 {
   "name": "ivue",
-  "version": "1.6.1",
+  "version": "2.0.0",
   "description": "Infinite Vue – Class Based Architecture for Vue 3",
   "type": "module",
   "exports": {
     ".": {
-      "require": "./dist/index.umd.js",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.es.js",
-      "types": "./dist/index.d.ts"
-    }
+      "require": "./dist/index.umd.js"
+    },
+    "./package.json": "./package.json"
   },
   "main": "./dist/index.umd.js",
   "module": "./dist/index.es.js",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "dev": "vite dev --host",
+    "dev": "vite demo --host",
+    "dev:demo": "vite demo --host",
+    "dev:flyweight": "vite examples/playground --port 5181 --host",
+    "build:flyweight": "vite build examples/playground",
+    "preview:flyweight": "vite preview examples/playground --port 5181 --host",
+    "measure:flyweight": "node examples/playground/src/examples/flyweight-grid/measure.mjs",
+    "measure:formula": "node demo/formula/measure.mjs",
+    "measure:grid": "node demo/grid/measure.mjs",
+    "dev:docs": "npm --prefix docs_v2 run dev -- --port 5174",
     "test": "vitest --coverage.enabled=true --reporter=verbose --ui",
     "coverage": "vitest run --coverage",
+    "bench": "vitest bench --run",
+    "bench:node-namespace": "vite-node experiments/node-namespace/benchmark.ts",
     "cypress": "cypress run --component",
     "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",
-    "dev:demo": "vite demo --host",
+    "build:docs": "npm run sync:examples && npm --prefix docs_v2 run build",
+    "render:og": "node docs_v2/scripts/brand-image-generator.mjs og",
+    "render:form-header": "node docs_v2/scripts/brand-image-generator.mjs form-header",
     "preview:demo": "npm run build:demo && vite preview demo --host",
-    "release": "yarn build && yarn publish"
+    "preview:docs": "npm --prefix docs_v2 run preview",
+    "release": "npm run build && npm publish",
+    "sync:skill": "node -e \"const fs=require('fs');fs.mkdirSync('skills/ivue',{recursive:true});fs.copyFileSync('.claude/skills/ivue/SKILL.md','skills/ivue/SKILL.md')\"",
+    "prepack": "npm run sync:skill",
+    "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"
   },
   "peerDependencies": {
-    "vue": "^3.0.0",
+    "vue": "^3.2.0",
     "vue-demi": "*"
   },
   "peerDependenciesMeta": {
@@ -37,6 +57,7 @@
   "devDependencies": {
     "@cypress/vite-dev-server": "^5.0.2",
     "@cypress/vue": "^5.0.3",
+    "@quasar/extras": "^2.0.2",
     "@types/lodash": "^4.17.20",
     "@typescript-eslint/eslint-plugin": "^5.10.0",
     "@typescript-eslint/parser": "^5.10.0",
@@ -55,9 +76,12 @@
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-storybook": "^0.6.12",
     "eslint-plugin-vue": "^9.14.1",
+    "fast-formula-parser": "^1.0.19",
     "i": "^0.3.7",
     "jsdom": "^21.0.0",
     "npm": "^11.6.2",
+    "playwright": "^1.61.1",
+    "quasar": "^2.21.3",
     "rollup-plugin-terser": "^7.0.2",
     "typescript": "^5.9.3",
     "vite": "^4.0.4",
@@ -97,7 +121,12 @@
   },
   "files": [
     "lib",
-    "dist"
+    "dist",
+    "bin",
+    "skills"
   ],
-  "license": "MIT"
+  "license": "MIT",
+  "bin": {
+    "ivue": "bin/ivue.mjs"
+  }
 }