narraleaf-react 0.34.0 → 0.35.0

package/dist/game/nlcore/gameTypes.d.ts

@@ -410,6 +410,14 @@ export type GameConfig = {
          */
         guard: GuardConfig;
     };
+    /**
+     * Turn off text scaling for the whole game.
+     *
+     * Dialogue text is kept inside its box by being set down as it is typed. Turning this on
+     * leaves every line at the size it was written at, and a line longer than its box overflows it.
+     * @default false
+     */
+    disableTextScaling: boolean;
     /**
      * Override the default stage
      * @default null

package/dist/game/player/elements/say/Sentence.d.ts

@@ -37,18 +37,25 @@ export type TextAppearanceProps = {
      */
     tateChuYoko?: TateChuYoko;
     /**
-     * Set the line down until the whole of it fits the box it is placed in.
+     * Keep the line inside the box it is placed in by setting it down as it is typed.
      *
-     * `fontSize` becomes a ceiling rather than a fixed size: the line is set at it whenever the
-     * finished line fits, and smaller when it does not, down to {@link autoFitMinFontSize}. Sizes
-     * carried by the sentence or by a single word scale with it, so their relative weights hold.
+     * The line is set at `fontSize` and stays there for as long as it fits, so a short line is
+     * never set small. Once the text reaches the end of the box, every further character is
+     * measured and the size comes down by what it takes to fit, to no less than
+     * {@link autoFitMinFontSize}. A line that still overflows at that size is left overflowing.
      *
-     * The box is the container's parent, which needs a size of its own for anything to be fitted to.
-     * @default false
+     * Sizes carried by the sentence or by a single word are scaled with the line rather than
+     * replaced, so their relative weights hold at any size, and a run set larger or smaller inside
+     * the line is accounted for by having been drawn rather than by being predicted.
+     *
+     * The box is the container's parent, which needs a size of its own for anything to be fitted
+     * to. {@link GameConfig.disableTextScaling} turns this off for the whole game.
+     * @default true
      */
     autoFit?: boolean;
     /**
-     * The smallest size auto fit sets, in px. A line that still overflows at it is left overflowing.
+     * The smallest size text scaling sets, in px. A line that still overflows at it is left
+     * overflowing.
      * @default 12
      */
     autoFitMinFontSize?: number;

package/dist/game/player/elements/say/autoFit.d.ts

@@ -1,43 +1,49 @@
 import React from "react";
-/** Smallest size auto fit sets when the line does not say otherwise. */
+/** Smallest size text scaling sets when the line does not say otherwise. */
 export declare const DEFAULT_AUTO_FIT_MIN_FONT_SIZE = 12;
-/** Set on the measuring copy so every explicit word size scales with one write. */
-export declare const AUTO_FIT_SCALE_VAR = "--nl-auto-fit-scale";
 /**
- * The same length, scaled, whatever unit it was written in.
+ * The multiplier every size in the line is written against.
  *
- * The multiplier is a number for the line on screen and the scale custom property for the copy
- * being measured, where one write has to resize every word at once.
+ * One custom property drives the container and every word inside it, so a candidate size is one
+ * write rather than a walk over the elements, and a word that carries a size of its own keeps its
+ * weight against the rest of the line at every scale.
  */
-export declare function scaledFontSize(value: React.CSSProperties["fontSize"], scale: number | string): React.CSSProperties["fontSize"];
-/** The multiplier the measuring copy scales by, readable from every word inside it. */
-export declare const AUTO_FIT_SCALE_MULTIPLIER = "var(--nl-auto-fit-scale, 1)";
-/** What the line is set at when it inherits its size: a share of the size it inherits. */
-export declare function inheritedScaledFontSize(scale: number): React.CSSProperties["fontSize"] | undefined;
+export declare const AUTO_FIT_SCALE_VAR = "--nl-text-scale";
+export declare const AUTO_FIT_SCALE_MULTIPLIER = "var(--nl-text-scale, 1)";
+/** The same length, scaled by the line's current multiplier, whatever unit it was written in. */
+export declare function scaledFontSize(value: React.CSSProperties["fontSize"]): React.CSSProperties["fontSize"];
+/** What the line is set at when it inherits its size: the inherited size, scaled. */
+export declare function inheritedScaledFontSize(): React.CSSProperties["fontSize"];
 export type AutoFitOptions = {
     enabled: boolean;
     /** The floor, in px. A line that overflows at this size is left overflowing rather than set smaller. */
     minFontSize: number;
     /** Vertical writing swaps the axes: the columns advance across the box, not down it. */
     vertical: boolean;
-    /** Everything that changes the laid-out result without changing the box. */
-    signature: string;
+    /**
+     * What has been typed so far. The line is measured again every time this changes, which is what
+     * makes the size follow the text rather than a guess made before it existed.
+     */
+    revealed: number;
 };
 export type AutoFitState = {
     containerRef: React.MutableRefObject<HTMLDivElement | null>;
-    mirrorRef: React.MutableRefObject<HTMLDivElement | null>;
-    /** The share of the authored size the line is set at. */
+    /** The share of the authored size the line is currently set at. */
     scale: number;
 };
 /**
- * Finds the largest size at which a whole line still fits the box it is placed in.
+ * Keeps a line inside its box while it is being typed.
  *
- * The line being typed is not what has to fit - the finished line is - so the search runs against a
- * hidden copy holding every word, laid out under the same box, the same typeface and the same
- * wrapping rules. The copy is what the bisection resizes; the visible line is set once, when the
- * answer is known, and stays there for the rest of the line.
+ * The line is set at the size it was written at and stays there for as long as it fits, so a short
+ * line is never set small "just in case". The moment the text reaches the bottom of the box, the
+ * next character brings the size down by whatever it takes to fit, and every character after it is
+ * measured again. So the size follows what is actually on screen: a run of larger or smaller words
+ * inside the line is accounted for by having been rendered, not by being predicted.
  *
- * The box is the container's parent: a dialog box has a size of its own, and the line is what has
- * to live inside it. A parent with no height of its own leaves the scale at 1.
+ * Within one line the size only ever comes down, since the text only ever grows. A change in the
+ * size of the box starts the line over at its authored size.
+ *
+ * The box is the container's parent, which is the element the host sized. A parent with no height
+ * of its own leaves the line at its authored size.
  */
-export declare function useAutoFitScale({ enabled, minFontSize, vertical, signature }: AutoFitOptions): AutoFitState;
+export declare function useAutoFitScale({ enabled, minFontSize, vertical, revealed }: AutoFitOptions): AutoFitState;