tutuca 0.9.71 → 0.9.73

package/dist/tutuca-extra.ext.js

@@ -1,114 +1,3 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __reExport = (target, mod, secondTarget) => {
-  var keys = __getOwnPropNames(mod);
-  for (let key of keys)
-    if (!__hasOwnProp.call(target, key) && key !== "default")
-      __defProp(target, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (secondTarget) {
-    for (let key of keys)
-      if (!__hasOwnProp.call(secondTarget, key) && key !== "default")
-        __defProp(secondTarget, key, {
-          get: __accessProp.bind(mod, key),
-          enumerable: true
-        });
-    return secondTarget;
-  }
-};
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-
-// extra.js
-var exports_extra = {};
-__export(exports_extra, {
-  tutuca: () => tutuca,
-  test: () => test,
-  macro: () => macro,
-  isOMap: () => isOrderedMap,
-  isIMap: () => isMap,
-  injectCss: () => injectCss,
-  html: () => html,
-  css: () => css,
-  component: () => component,
-  compileClassesToStyleText: () => compileClassesToStyleText,
-  compileClassesToStyle: () => compileClassesToStyle,
-  collectIterBindings: () => collectIterBindings,
-  check: () => check,
-  SEQ_INFO: () => SEQ_INFO,
-  ParseContext: () => ParseContext,
-  OMap: () => OrderedMap2,
-  KList: () => KList,
-  ISet: () => Set2,
-  IMap: () => Map2,
-  FIELD_CLASS: () => FIELD_CLASS
-});
-
-// src/app.js
-var exports_app = {};
-__export(exports_app, {
-  injectCss: () => injectCss,
-  App: () => App
-});
-
-// src/components.js
-var exports_components = {};
-__export(exports_components, {
-  DynamicAlias: () => DynamicAlias,
-  Dynamic: () => Dynamic,
-  Components: () => Components,
-  ComponentStack: () => ComponentStack,
-  Component: () => Component
-});
-
-// src/anode.js
-var exports_anode = {};
-__export(exports_anode, {
-  compileModifiers: () => compileModifiers,
-  WrapperNode: () => WrapperNode,
-  View: () => View,
-  TextNode: () => TextNode,
-  SlotNode: () => SlotNode,
-  ShowNode: () => ShowNode,
-  ScopeNode: () => ScopeNode,
-  RenderTextNode: () => RenderTextNode,
-  RenderOnceNode: () => RenderOnceNode,
-  RenderNode: () => RenderNode,
-  RenderItNode: () => RenderItNode,
-  RenderEachNode: () => RenderEachNode,
-  PushViewNameNode: () => PushViewNameNode,
-  ParseContext: () => ParseContext,
-  NodeEvents: () => NodeEvents,
-  MacroNode: () => MacroNode,
-  Macro: () => Macro,
-  MOD_WRAPPERS_BY_EVENT: () => MOD_WRAPPERS_BY_EVENT,
-  IterInfo: () => IterInfo,
-  HideNode: () => HideNode,
-  FragmentNode: () => FragmentNode,
-  EachNode: () => EachNode,
-  DomNode: () => DomNode,
-  CommentNode: () => CommentNode,
-  BaseNode: () => BaseNode,
-  ANode: () => ANode
-});
-
 // src/value.js
 import { is } from "immutable";
 
@@ -3338,11 +3227,6 @@ class DragInfo {
 }
 
 // src/util/parsectx.js
-var exports_parsectx = {};
-__export(exports_parsectx, {
-  collectAppClassesInSet: () => collectAppClassesInSet,
-  ParseCtxClassSetCollector: () => ParseCtxClassSetCollector
-});
 class ParseCtxClassSetCollector extends ParseContext {
   constructor(...args) {
     super(...args);
@@ -3398,48 +3282,11 @@ class ParseCtxClassSetCollector extends ParseContext {
     return false;
   }
 }
-function collectAppClassesInSet(app) {
-  const classes = new Set;
-  for (const Comp of app.comps.byId.values()) {
-    for (const key in Comp.views) {
-      const view = Comp.views[key];
-      for (const name of view.ctx.classes) {
-        classes.add(name);
-      }
-    }
-  }
-  return classes;
-}
 
 // extra/klist.js
-var exports_klist = {};
-__export(exports_klist, {
-  KList: () => KList,
-  FieldKList: () => FieldKList
-});
 import { Map as IMap2, List as List2 } from "immutable";
 
 // src/oo.js
-var exports_oo = {};
-__export(exports_oo, {
-  getTypeName: () => getTypeName,
-  fieldsByTypeName: () => fieldsByTypeName,
-  extendProtoForKeyed: () => extendProtoForKeyed,
-  component: () => component,
-  classFromData: () => classFromData,
-  FieldString: () => FieldString,
-  FieldSet: () => FieldSet,
-  FieldOMap: () => FieldOMap,
-  FieldMap: () => FieldMap,
-  FieldList: () => FieldList,
-  FieldInt: () => FieldInt,
-  FieldFloat: () => FieldFloat,
-  FieldComp: () => FieldComp,
-  FieldBool: () => FieldBool,
-  FieldAny: () => FieldAny,
-  Field: () => Field,
-  FIELD_CLASS: () => FIELD_CLASS
-});
 import { Map as IMap, Set as ISet, List, OrderedMap, Record } from "immutable";
 var BAD_VALUE = Symbol("BadValue");
 var nullCoercer = (v) => v;
@@ -3823,15 +3670,6 @@ function classFromData(name, { fields = {}, methods, statics }) {
 var component = (opts) => new Component(classFromData(opts.name, opts), opts);
 
 // src/renderer.js
-var exports_renderer = {};
-__export(exports_renderer, {
-  unpackLoopResult: () => unpackLoopResult,
-  normalizeRange: () => normalizeRange,
-  getSeqInfo: () => getSeqInfo,
-  SEQ_INFO: () => SEQ_INFO,
-  Renderer: () => Renderer,
-  DATASET_ATTRS: () => DATASET_ATTRS
-});
 import { isIndexed, isKeyed } from "immutable";
 
 // src/cache.js
@@ -4150,34 +3988,58 @@ KList.prototype[SEQ_INFO] = (seq, visit) => {
     visit(k, seq.items.get(k), "data-sk");
 };
 // index.js
-var exports_tutuca = {};
-__export(exports_tutuca, {
-  tutuca: () => tutuca,
-  test: () => test,
-  macro: () => macro,
-  isOMap: () => isOrderedMap,
-  isIMap: () => isMap,
-  injectCss: () => injectCss,
-  html: () => html,
-  css: () => css,
-  component: () => component,
-  collectIterBindings: () => collectIterBindings,
-  check: () => check,
-  SEQ_INFO: () => SEQ_INFO,
-  ParseContext: () => ParseContext,
-  OMap: () => OrderedMap2,
-  ISet: () => Set2,
-  IMap: () => Map2,
-  FIELD_CLASS: () => FIELD_CLASS
-});
-__reExport(exports_tutuca, immutable);
-import"immutable";
 import {
-  isMap,
-  isOrderedMap,
+  Collection,
+  List as List3,
   Map as Map2,
   OrderedMap as OrderedMap2,
-  Set as Set2
+  OrderedSet,
+  PairSorting,
+  Range,
+  Record as Record2,
+  Repeat,
+  Seq,
+  Set as Set2,
+  Stack as Stack2,
+  fromJS,
+  get,
+  getIn,
+  has,
+  hasIn,
+  hash,
+  is as is2,
+  isAssociative,
+  isCollection,
+  isImmutable,
+  isIndexed as isIndexed2,
+  isKeyed as isKeyed2,
+  isList,
+  isMap,
+  isOrdered,
+  isOrderedMap,
+  isOrderedSet,
+  isPlainObject,
+  isRecord,
+  isSeq,
+  isSet,
+  isStack,
+  isValueObject,
+  merge,
+  mergeDeep,
+  mergeDeepWith,
+  mergeWith,
+  remove,
+  removeIn,
+  set,
+  setIn,
+  update,
+  updateIn,
+  version,
+  isMap as isMap2,
+  isOrderedMap as isOrderedMap2,
+  Map as Map3,
+  OrderedMap as OrderedMap3,
+  Set as Set3
 } from "immutable";
 var css = String.raw;
 var html = String.raw;
@@ -4200,7 +4062,6 @@ function tutuca(nodeOrSelector) {
 }
 
 // extra.js
-__reExport(exports_extra, exports_tutuca);
 async function compileClassesToStyle(app, compileClasses, styleId = "margaui-css") {
   const t1 = performance.now();
   const css2 = await compileClassesToStyleText(app, compileClasses);
@@ -4222,24 +4083,70 @@ async function compileClassesToStyleText(app, compileClasses, Ctx = ParseCtxClas
   return await compileClasses(Array.from(classes));
 }
 export {
+  version,
+  updateIn,
+  update,
   tutuca,
   test,
+  setIn,
+  set,
+  removeIn,
+  remove,
+  mergeWith,
+  mergeDeepWith,
+  mergeDeep,
+  merge,
   macro,
-  isOrderedMap as isOMap,
-  isMap as isIMap,
+  isValueObject,
+  isStack,
+  isSet,
+  isSeq,
+  isRecord,
+  isPlainObject,
+  isOrderedSet,
+  isOrderedMap,
+  isOrdered,
+  isOrderedMap2 as isOMap,
+  isMap,
+  isList,
+  isKeyed2 as isKeyed,
+  isIndexed2 as isIndexed,
+  isImmutable,
+  isMap2 as isIMap,
+  isCollection,
+  isAssociative,
+  is2 as is,
   injectCss,
   html,
+  hash,
+  hasIn,
+  has,
+  getIn,
+  get,
+  fromJS,
   css,
   component,
   compileClassesToStyleText,
   compileClassesToStyle,
   collectIterBindings,
   check,
+  Stack2 as Stack,
+  Set2 as Set,
+  Seq,
   SEQ_INFO,
+  Repeat,
+  Record2 as Record,
+  Range,
   ParseContext,
-  OrderedMap2 as OMap,
+  PairSorting,
+  OrderedSet,
+  OrderedMap2 as OrderedMap,
+  OrderedMap3 as OMap,
+  Map2 as Map,
+  List3 as List,
   KList,
-  Set2 as ISet,
-  Map2 as IMap,
-  FIELD_CLASS
+  Set3 as ISet,
+  Map3 as IMap,
+  FIELD_CLASS,
+  Collection
 };

package/dist/tutuca.ext.js

@@ -3450,13 +3450,58 @@ var unkIter = () => {};
 var SEQ_INFO = Symbol.for("tutuca.seqInfo");
 
 // index.js
-export * from "immutable";
 import {
-  isMap,
-  isOrderedMap,
+  Collection,
+  List as List2,
   Map as Map2,
   OrderedMap as OrderedMap2,
-  Set as Set2
+  OrderedSet,
+  PairSorting,
+  Range,
+  Record as Record2,
+  Repeat,
+  Seq,
+  Set as Set2,
+  Stack as Stack2,
+  fromJS,
+  get,
+  getIn,
+  has,
+  hasIn,
+  hash,
+  is as is2,
+  isAssociative,
+  isCollection,
+  isImmutable,
+  isIndexed as isIndexed2,
+  isKeyed as isKeyed2,
+  isList,
+  isMap,
+  isOrdered,
+  isOrderedMap,
+  isOrderedSet,
+  isPlainObject,
+  isRecord,
+  isSeq,
+  isSet,
+  isStack,
+  isValueObject,
+  merge,
+  mergeDeep,
+  mergeDeepWith,
+  mergeWith,
+  remove,
+  removeIn,
+  set,
+  setIn,
+  update,
+  updateIn,
+  version,
+  isMap as isMap2,
+  isOrderedMap as isOrderedMap2,
+  Map as Map3,
+  OrderedMap as OrderedMap3,
+  Set as Set3
 } from "immutable";
 
 // src/oo.js
@@ -3863,21 +3908,67 @@ function tutuca(nodeOrSelector) {
   return new App(rootNode, comps, renderer, ParseContext);
 }
 export {
+  version,
+  updateIn,
+  update,
   tutuca,
   test,
+  setIn,
+  set,
+  removeIn,
+  remove,
+  mergeWith,
+  mergeDeepWith,
+  mergeDeep,
+  merge,
   macro,
-  isOrderedMap as isOMap,
-  isMap as isIMap,
+  isValueObject,
+  isStack,
+  isSet,
+  isSeq,
+  isRecord,
+  isPlainObject,
+  isOrderedSet,
+  isOrderedMap,
+  isOrdered,
+  isOrderedMap2 as isOMap,
+  isMap,
+  isList,
+  isKeyed2 as isKeyed,
+  isIndexed2 as isIndexed,
+  isImmutable,
+  isMap2 as isIMap,
+  isCollection,
+  isAssociative,
+  is2 as is,
   injectCss,
   html,
+  hash,
+  hasIn,
+  has,
+  getIn,
+  get,
+  fromJS,
   css,
   component,
   collectIterBindings,
   check,
+  Stack2 as Stack,
+  Set2 as Set,
+  Seq,
   SEQ_INFO,
+  Repeat,
+  Record2 as Record,
+  Range,
   ParseContext,
-  OrderedMap2 as OMap,
-  Set2 as ISet,
-  Map2 as IMap,
-  FIELD_CLASS
+  PairSorting,
+  OrderedSet,
+  OrderedMap2 as OrderedMap,
+  OrderedMap3 as OMap,
+  Map2 as Map,
+  List2 as List,
+  Set3 as ISet,
+  Map3 as IMap,
+  FIELD_CLASS,
+  Collection
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tutuca",
-  "version": "0.9.71",
+  "version": "0.9.73",
   "type": "module",
   "description": "Zero-dependency SPA framework with immutable state and virtual DOM",
   "main": "./dist/tutuca.js",
@@ -13,6 +13,8 @@
     "./ext": "./dist/tutuca.ext.js",
     "./extra-ext": "./dist/tutuca-extra.ext.js",
     "./dev-ext": "./dist/tutuca-dev.ext.js",
+    "./immutable": "./dist/immutable.js",
+    "./chai": "./dist/chai.js",
     "./package.json": "./package.json"
   },
   "bin": {
@@ -23,7 +25,8 @@
     "dist": "bun scripts/dist.js",
     "dist-ext": "bun scripts/dist-ext.js",
     "dist-immutable": "bun scripts/dist-immutable.js",
-    "dist-all": "bun run dist-immutable && bun run dist && bun run dist-ext",
+    "dist-all": "bun run dist-immutable && bun run dist && bun run dist-ext && bun run smoke",
+    "smoke": "node scripts/smoke.js",
     "release": "bun run dist-all && bun run build-skill && npm publish --access public",
     "release-dry": "bun run dist-all && bun run build-skill && npm publish --dry-run",
     "build-skill": "bun scripts/build-skill.js",
@@ -49,6 +52,8 @@
     "dist/tutuca.ext.js",
     "dist/tutuca-extra.ext.js",
     "dist/tutuca-dev.ext.js",
+    "dist/immutable.js",
+    "dist/chai.js",
     "skill"
   ],
   "dependencies": {
@@ -56,9 +61,13 @@
     "prettier": "^3.0.0"
   },
   "peerDependencies": {
+    "chai": "^6.2.2",
     "immutable": "*"
   },
   "peerDependenciesMeta": {
+    "chai": {
+      "optional": true
+    },
     "immutable": {
       "optional": true
     }

package/skill/tutuca/cli.md

@@ -158,25 +158,25 @@ export function getTests({ describe, test, expect }) {
     describe("inc()", () => {                           // method
       test("returns a Counter with count + 1", () => {
         const next = Counter.make().inc();
-        expect(next).to.be.instanceOf(Counter.Class);
-        expect(next.count).to.equal(1);
+        expect(next).toBeInstanceOf(Counter.Class);
+        expect(next.count).toBe(1);
       });
       test("does not mutate the original instance", () => {
         const c = Counter.make({ count: 7 });
         c.inc();
-        expect(c.count).to.equal(7);                    // immutability
+        expect(c.count).toBe(7);                    // immutability
       });
     });
 
     describe("dec()", () => {                           // input handler
       test("returns a Counter with count - 1", () => {
         const next = Counter.input.dec.call(Counter.make());
-        expect(next.count).to.equal(-1);
+        expect(next.count).toBe(-1);
       });
     });
 
     test("inc and dec round-trip", () => {              // untagged path
-      expect(Counter.input.dec.call(Counter.make().inc()).count).to.equal(0);
+      expect(Counter.input.dec.call(Counter.make().inc()).count).toBe(0);
     });
   });
 }

package/skill/tutuca/core.md

@@ -514,6 +514,17 @@ input: { onPick(detail) { return this.setCurrent(detail.unicode); } }
 view: html`<emoji-picker @on.emoji-click="onPick value"></emoji-picker>`,
 ```
 
+Handle these events declaratively with `@on.<event-name>` in the view —
+don't grab the node from host/glue code and `addEventListener` on it. A
+listener attached from outside the component runs outside the handler
+model: no `return this.set…()`, no transactor batching, and the mutation
+is invisible to the component that owns the state (the same hazard as
+reaching into `app.state` directly). For any event with a real element in
+the tree, `@on.` is the only entry point you need. Genuinely external
+inbound sources (WebSocket, `postMessage`, timers) have no element to bind
+— route those through `app.sendAtRoot` instead (see
+[request-response.md](./request-response.md)).
+
 Pitfall: binding camelCase JS properties on a custom element silently
 fails. `:mapId=".id"` does *not* invoke a `set mapId` setter
 — the HTML parser lowercased the attribute name, so the framework assigns

package/skill/tutuca/testing.md

@@ -16,13 +16,19 @@ A module opts into `tutuca test` by exporting `getTests`:
 export function getTests({ describe, test, expect }) {
   describe(MyComp, () => {
     test("does the thing", () => {
-      expect(MyComp.make().doTheThing().count).to.equal(1);
+      expect(MyComp.make().doTheThing().count).toBe(1);
     });
   });
 }
 ```
 
-- `expect` is chai.
+- `expect` is chai, extended with **jest-style matchers** (`toBe`,
+  `toEqual`, `toContain`, `toThrow`, `.not.toBe`, …) — the recommended
+  style. Chai's BDD chain (`expect(x).to.equal(1)`) still works for those
+  who prefer it. Run `tutuca help` for the full matcher list (it's
+  surfaced from code). Asymmetric/mock matchers
+  (`expect.objectContaining`, `toHaveBeenCalled…`, `toMatchSnapshot`) are
+  **not** available — tutuca has no mocking layer.
 - `test` and `describe` are **Tutuca's own** subset of the common
   Mocha/Bun-style API, injected by `tutuca test` — not Bun's built-ins.
   Available calls: `describe(title, fn)`, `describe(Component, fn)`,
@@ -147,7 +153,7 @@ test("filters and enriches", () => {
     when: "keepEven",
     enrichWith: "addLabel",
   });
-  expect(r).to.deep.equal([
+  expect(r).toEqual([
     { key: 0, value: 10, label: "0/4: 10" },
     { key: 2, value: 30, label: "2/4: 30" },
   ]);
@@ -211,8 +217,8 @@ input: { setCount(n) { return this.setCount(n); } }
 At test time, the "good" forms become trivial:
 
 ```js
-expect(MyComp.make().setName("Ada").name).to.equal("Ada");
-expect(MyComp.input.setCount.call(MyComp.make(), 42).count).to.equal(42);
+expect(MyComp.make().setName("Ada").name).toBe("Ada");
+expect(MyComp.input.setCount.call(MyComp.make(), 42).count).toBe(42);
 ```
 
 The "bad" forms force every test to construct
@@ -237,31 +243,31 @@ export function getTests({ describe, test, expect }) {
   describe(Counter, () => {
     describe("inc()", () => {                         // method
       test("returns a Counter with count + 1", () => {
-        expect(Counter.make().inc().count).to.equal(1);
+        expect(Counter.make().inc().count).toBe(1);
       });
       test("does not mutate the original instance", () => {
         const c = Counter.make({ count: 7 });
         c.inc();
-        expect(c.count).to.equal(7);
+        expect(c.count).toBe(7);
       });
     });
 
     describe("dec()", () => {                         // input handler, no args
       test("returns a Counter with count - 1", () => {
         const next = Counter.input.dec.call(Counter.make());
-        expect(next.count).to.equal(-1);
+        expect(next.count).toBe(-1);
       });
     });
 
     describe("setCount()", () => {                    // input handler, valueAsInt
       test("sets the count from a parsed int", () => {
         const next = Counter.input.setCount.call(Counter.make(), 42);
-        expect(next.count).to.equal(42);
+        expect(next.count).toBe(42);
       });
     });
 
     test("inc and dec round-trip", () => {            // untagged, inherits Counter
-      expect(Counter.input.dec.call(Counter.make().inc()).count).to.equal(0);
+      expect(Counter.input.dec.call(Counter.make().inc()).count).toBe(0);
     });
   });
 }