narraleaf-react 0.33.1 → 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

@@ -36,6 +36,29 @@ export type TextAppearanceProps = {
      * @default true
      */
     tateChuYoko?: TateChuYoko;
+    /**
+     * Keep the line inside the box it is placed in by setting it down as it is typed.
+     *
+     * 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.
+     *
+     * 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 text scaling sets, in px. A line that still overflows at it is left
+     * overflowing.
+     * @default 12
+     */
+    autoFitMinFontSize?: number;
 };
 export type BaseTextsProps = TextAppearanceProps & {
     className?: string;

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

@@ -0,0 +1,49 @@
+import React from "react";
+/** Smallest size text scaling sets when the line does not say otherwise. */
+export declare const DEFAULT_AUTO_FIT_MIN_FONT_SIZE = 12;
+/**
+ * The multiplier every size in the line is written against.
+ *
+ * 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 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;
+    /**
+     * 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>;
+    /** The share of the authored size the line is currently set at. */
+    scale: number;
+};
+/**
+ * Keeps a line inside its box while it is being typed.
+ *
+ * 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.
+ *
+ * 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, revealed }: AutoFitOptions): AutoFitState;