foldkit 0.141.0 → 0.141.1

package/dist/html/lazy.d.ts

@@ -18,13 +18,28 @@ import { type VNode } from '../vdom.js';
  *  DOM nodes. If the same content needs to appear in multiple positions,
  *  create one slot per position. */
 export declare const createLazy: () => (<Args extends ReadonlyArray<unknown>>(fn: (...args: Args) => VNode | null, args: Args) => VNode | null);
-/** Creates a keyed memoization map for view functions rendered in a loop. Each
- *  key gets its own independent cache slot. On each render, only entries whose
- *  function reference, dispatch, or arguments have changed by reference are
- *  recomputed.
+/** Creates a keyed memoization map for one view function rendered under many
+ *  keys. Each key gets its own independent cache slot, compared exactly the way
+ *  `createLazy` compares its single slot: on each render, only the keys whose
+ *  function reference, dispatch, or arguments changed by reference are
+ *  recomputed. For example: a list rendering one row view per item, a detail
+ *  view rendering one entity per route, or one view function rendered at two
+ *  call sites.
+ *
+ *  Key by the identifier that already gives the rendered thing its DOM
+ *  identity. A row keyed `todo.id` through `h.keyed` memoizes under `todo.id`;
+ *  a detail page keyed `post.slug` memoizes under `post.slug`. Reusing that one
+ *  identifier keeps the memo and the DOM invalidating together.
+ *
+ *  Entries are never evicted, so keys are expected to be bounded, such as an
+ *  entity registry, a route table, or a fixed set of call sites. A key drawn
+ *  from something unbounded, such as a search query or a paged cursor, grows
+ *  the map for the lifetime of the page. If that becomes the shape an app
+ *  needs, the upgrade path is a variant that drops keys absent from the latest
+ *  render pass, not a cap on this one.
  *
  *  Like `createLazy`, each key's cached VNode must be rendered at a single
- *  position in the tree. If the same item needs to appear in multiple
- *  positions, create one keyed lazy per position. */
+ *  position in the tree. If the same content needs to appear in multiple
+ *  positions, give each position its own key. */
 export declare const createKeyedLazy: () => (<Args extends ReadonlyArray<unknown>>(key: PropertyKey, fn: (...args: Args) => VNode | null, args: Args) => VNode | null);
 //# sourceMappingURL=lazy.d.ts.map

package/dist/html/lazy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/html/lazy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,KAAK,EAAwC,MAAM,YAAY,CAAA;AAmF7E;;;;;;;;;;;;;;;;;oCAiBoC;AACpC,eAAO,MAAM,UAAU,QAAO,CAAC,CAAC,IAAI,SAAS,aAAa,CAAC,OAAO,CAAC,EACjE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,KAAK,GAAG,IAAI,EACnC,IAAI,EAAE,IAAI,KACP,KAAK,GAAG,IAAI,CAUhB,CAAA;AAED;;;;;;;qDAOqD;AACrD,eAAO,MAAM,eAAe,QAAO,CAAC,CAAC,IAAI,SAAS,aAAa,CAAC,OAAO,CAAC,EACtE,GAAG,EAAE,WAAW,EAChB,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,KAAK,GAAG,IAAI,EACnC,IAAI,EAAE,IAAI,KACP,KAAK,GAAG,IAAI,CAWhB,CAAA"}
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/html/lazy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,KAAK,EAAwC,MAAM,YAAY,CAAA;AAmF7E;;;;;;;;;;;;;;;;;oCAiBoC;AACpC,eAAO,MAAM,UAAU,QAAO,CAAC,CAAC,IAAI,SAAS,aAAa,CAAC,OAAO,CAAC,EACjE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,KAAK,GAAG,IAAI,EACnC,IAAI,EAAE,IAAI,KACP,KAAK,GAAG,IAAI,CAUhB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;iDAsBiD;AACjD,eAAO,MAAM,eAAe,QAAO,CAAC,CAAC,IAAI,SAAS,aAAa,CAAC,OAAO,CAAC,EACtE,GAAG,EAAE,WAAW,EAChB,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,KAAK,GAAG,IAAI,EACnC,IAAI,EAAE,IAAI,KACP,KAAK,GAAG,IAAI,CAWhB,CAAA"}

package/dist/html/lazy.js

@@ -72,14 +72,29 @@ export const createLazy = () => {
         cached = entry;
     });
 };
-/** Creates a keyed memoization map for view functions rendered in a loop. Each
- *  key gets its own independent cache slot. On each render, only entries whose
- *  function reference, dispatch, or arguments have changed by reference are
- *  recomputed.
+/** Creates a keyed memoization map for one view function rendered under many
+ *  keys. Each key gets its own independent cache slot, compared exactly the way
+ *  `createLazy` compares its single slot: on each render, only the keys whose
+ *  function reference, dispatch, or arguments changed by reference are
+ *  recomputed. For example: a list rendering one row view per item, a detail
+ *  view rendering one entity per route, or one view function rendered at two
+ *  call sites.
+ *
+ *  Key by the identifier that already gives the rendered thing its DOM
+ *  identity. A row keyed `todo.id` through `h.keyed` memoizes under `todo.id`;
+ *  a detail page keyed `post.slug` memoizes under `post.slug`. Reusing that one
+ *  identifier keeps the memo and the DOM invalidating together.
+ *
+ *  Entries are never evicted, so keys are expected to be bounded, such as an
+ *  entity registry, a route table, or a fixed set of call sites. A key drawn
+ *  from something unbounded, such as a search query or a paged cursor, grows
+ *  the map for the lifetime of the page. If that becomes the shape an app
+ *  needs, the upgrade path is a variant that drops keys absent from the latest
+ *  render pass, not a cap on this one.
  *
  *  Like `createLazy`, each key's cached VNode must be rendered at a single
- *  position in the tree. If the same item needs to appear in multiple
- *  positions, create one keyed lazy per position. */
+ *  position in the tree. If the same content needs to appear in multiple
+ *  positions, give each position its own key. */
 export const createKeyedLazy = () => {
     const cache = new Map();
     return (key, fn, args) => resolveOrCache(cache.get(key), fn, args, entry => {

package/dist/update/update.d.ts

@@ -212,12 +212,12 @@ export type FoldWithOutMessage<ParentModel, ParentMessage, Input, ParentOutMessa
  *  of the child's:
  *
  *  ```ts
- *  const joinRoom = (roomId: string, player: Player): UpdateStep =>
+ *  const enterJoinedRoom = (roomId: string, player: Player): UpdateStep =>
  *    Update.combine([
  *      model => [model, [NavigateToRoom({ roomId })]],
  *      Update.foldChild({
- *        update: (room: Room.Model, player: Player) =>
- *          Room.join(room, player, { roomId }),
+ *        update: (room: Room.Model, joinedPlayer: Player) =>
+ *          Room.informJoined(room, joinedPlayer, { roomId }),
  *        read: readRoom,
  *        write: writeRoom,
  *        toParentMessage: toGotRoomMessage,

package/dist/update/update.js

@@ -88,12 +88,12 @@ export const refresh = (refreshable) => model => pipe(refreshable.read(model), O
  *  of the child's:
  *
  *  ```ts
- *  const joinRoom = (roomId: string, player: Player): UpdateStep =>
+ *  const enterJoinedRoom = (roomId: string, player: Player): UpdateStep =>
  *    Update.combine([
  *      model => [model, [NavigateToRoom({ roomId })]],
  *      Update.foldChild({
- *        update: (room: Room.Model, player: Player) =>
- *          Room.join(room, player, { roomId }),
+ *        update: (room: Room.Model, joinedPlayer: Player) =>
+ *          Room.informJoined(room, joinedPlayer, { roomId }),
  *        read: readRoom,
  *        write: writeRoom,
  *        toParentMessage: toGotRoomMessage,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foldkit",
-  "version": "0.141.0",
+  "version": "0.141.1",
   "description": "A TypeScript frontend framework, built on Effect and architected like Elm",
   "type": "module",
   "main": "./dist/index.js",