@promptctl/rich-js 0.22.0 → 0.23.0

package/dist/core/strip.d.ts

@@ -77,11 +77,11 @@ export interface Joiner<T extends StyledRenderable = StyledRenderable> {
  */
 export declare const JOIN: object;
 /**
- * Which of a cell's two colours on screen are `owner`'s: both, for a cell
- * `owner` drew, itself or through an owner nested in its output; for a cell a
- * `CellJoiner` drew, the sides shown in `owner`'s colour.
+ * Which of a cell's two colours on screen are one of `owners`': both, for a
+ * cell one of them drew, itself or through an owner nested in its output; for
+ * a cell a `CellJoiner` drew, the sides shown in one of their colours.
  */
-export declare function colorsOwnedBy(anchor: Anchor | undefined, owner: object): {
+export declare function colorsOwnedBy(anchor: Anchor | undefined, owners: ReadonlySet<object>): {
     readonly fg: boolean;
     readonly bg: boolean;
 };

package/dist/core/strip.js

@@ -59,16 +59,18 @@ class ColorOwners {
     }
 }
 /**
- * Which of a cell's two colours on screen are `owner`'s: both, for a cell
- * `owner` drew, itself or through an owner nested in its output; for a cell a
- * `CellJoiner` drew, the sides shown in `owner`'s colour.
+ * Which of a cell's two colours on screen are one of `owners`': both, for a
+ * cell one of them drew, itself or through an owner nested in its output; for
+ * a cell a `CellJoiner` drew, the sides shown in one of their colours.
  */
-export function colorsOwnedBy(anchor, owner) {
+export function colorsOwnedBy(anchor, owners) {
     for (let level = anchor; level; level = level.inner) {
-        if (level.owner === owner)
+        if (owners.has(level.owner))
             return { fg: true, bg: true };
-        if (level.owner instanceof ColorOwners)
-            return { fg: level.owner.fg === owner, bg: level.owner.bg === owner };
+        if (level.owner instanceof ColorOwners) {
+            const { fg, bg } = level.owner;
+            return { fg: fg !== null && owners.has(fg), bg: bg !== null && owners.has(bg) };
+        }
     }
     return { fg: false, bg: false };
 }

package/dist/renderables/effect.d.ts

@@ -6,7 +6,9 @@
  * draws in that frame in, a function of the frame out; and into that, a
  * cell's colours and where the cell is, the cell's new colours out. Whatever
  * holds for the whole frame is worked out in the first stage, once, and every
- * cell of the frame is handed to the second. Shimmer, pulse, fade and
+ * cell of the frame is handed to the second, but for those a wrapper keeps
+ * back: `confined` hands over only the cells its owners drew, so a second
+ * stage never counts on seeing them all. Shimmer, pulse, fade and
  * dissolve are all this one shape, differing by what the function does with
  * its inputs [LAW:one-type-per-behavior]; two effects stack by nesting one
  * wrapper in another, which is the same as calling one after the other but
@@ -170,14 +172,17 @@ export declare class Effected implements Renderable, Measurable {
     private seed;
 }
 /**
- * `effect` on the colours `owner` drew, itself or through an owner nested in
- * its output, and every other colour left as it is: one item of a strip whose
- * items share a fill, one widget of a screen. A seam cell shows its two
- * neighbours side by side, a powerline arrow in the fill it points out of
- * over the fill it points into, so each side moves with its own item
- * (`colorsOwnedBy`, `../core/strip.ts`).
+ * `effect` on the colours any of `owners` drew, itself or through an owner
+ * nested in its output, and every other colour left as it is: one item of a
+ * strip whose items share a fill, the items of a row one other item stands
+ * apart from, one widget of a screen. A seam cell shows its two neighbours
+ * side by side, a powerline arrow in the fill it points out of over the fill
+ * it points into, so each side moves with its own item (`colorsOwnedBy`,
+ * `../core/strip.ts`). A cell none of them drew is never handed to the
+ * effect, so confining one effect to many owners costs one call a cell, not
+ * one for each owner.
  */
-export declare function confined(effect: Effect, owner: object): Effect;
+export declare function confined(effect: Effect, ...owners: readonly object[]): Effect;
 /**
  * What `segments`, drawn at `depth` on `theme`, draw their words in, measured
  * as `Effected` measures its child for every frame. Measure an element's

package/dist/renderables/effect.js

@@ -6,7 +6,9 @@
  * draws in that frame in, a function of the frame out; and into that, a
  * cell's colours and where the cell is, the cell's new colours out. Whatever
  * holds for the whole frame is worked out in the first stage, once, and every
- * cell of the frame is handed to the second. Shimmer, pulse, fade and
+ * cell of the frame is handed to the second, but for those a wrapper keeps
+ * back: `confined` hands over only the cells its owners drew, so a second
+ * stage never counts on seeing them all. Shimmer, pulse, fade and
  * dissolve are all this one shape, differing by what the function does with
  * its inputs [LAW:one-type-per-behavior]; two effects stack by nesting one
  * wrapper in another, which is the same as calling one after the other but
@@ -185,18 +187,24 @@ function measured(looked, depth, theme) {
     return { pairs, colors: new Set([...own("fg"), ...own("bg")]), fills: new Set(own("bg")), depth, theme };
 }
 /**
- * `effect` on the colours `owner` drew, itself or through an owner nested in
- * its output, and every other colour left as it is: one item of a strip whose
- * items share a fill, one widget of a screen. A seam cell shows its two
- * neighbours side by side, a powerline arrow in the fill it points out of
- * over the fill it points into, so each side moves with its own item
- * (`colorsOwnedBy`, `../core/strip.ts`).
+ * `effect` on the colours any of `owners` drew, itself or through an owner
+ * nested in its output, and every other colour left as it is: one item of a
+ * strip whose items share a fill, the items of a row one other item stands
+ * apart from, one widget of a screen. A seam cell shows its two neighbours
+ * side by side, a powerline arrow in the fill it points out of over the fill
+ * it points into, so each side moves with its own item (`colorsOwnedBy`,
+ * `../core/strip.ts`). A cell none of them drew is never handed to the
+ * effect, so confining one effect to many owners costs one call a cell, not
+ * one for each owner.
  */
-export function confined(effect, owner) {
+export function confined(effect, ...owners) {
+    const confinedTo = new Set(owners);
     return (t, drawn) => {
         const frame = effect(t, drawn);
         return (colors, cell) => {
-            const owned = colorsOwnedBy(cell.anchor, owner);
+            const owned = colorsOwnedBy(cell.anchor, confinedTo);
+            if (!owned.fg && !owned.bg)
+                return colors;
             const moved = frame(colors, cell);
             return { fg: owned.fg ? moved.fg : colors.fg, bg: owned.bg ? moved.bg : colors.bg };
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promptctl/rich-js",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Rich text and beautiful formatting in the terminal — a TypeScript port of Python's Rich",
   "repository": {
     "type": "git",