@appinternalleads/ui 0.4.1 → 0.4.2

package/src/motion/typesurface/config.ts

@@ -7,6 +7,7 @@
  *   typography   how the letters look: font, weight, size, spacing, colour, gradient, blend mode
  *   placement    where the text sits ON the surface (surface coordinates, 0–1), its angle and width
  *   surface      which physical thing it meets (newspaper, bottle, wrapper…) and in which state
+ *   object       instead of a surface: something built from primitives (`construct.ts`), as JSON
  *   deformation  how far each transformation has gone: wrap, morph, fold, roll, crumple…
  *   material     how the letters become part of the surface: ink, print, foil, emboss
  *   view         the camera: perspective comes from here, not from the text
@@ -18,6 +19,7 @@
  * Angles are degrees, times are ms. `docs/TYPE-SURFACE.md`.
  */
 import type { Easing } from '../types';
+import { sanitizeObject, type TSObjectSpec } from './construct';
 import { hasSurface } from './surfaces';
 
 export const TS_SURFACES = ['newspaper', 'paper', 'bottle', 'wrapper', 'fabric'] as const;
@@ -73,7 +75,8 @@ export type TSPlacement = {
 };
 
 export type TSSurface = {
-  type: TSSurfaceType;
+  /** A built-in surface, or `object` when the config's `object` is what the text meets. */
+  type: TSSurfaceType | 'object';
   /** A named state from `SURFACE_STATES[type]`; applying it sets `deformation`. Informational after. */
   state: string;
   /** Seeds every random choice: creases, wrinkles, the newspaper's copy and photos. */
@@ -222,6 +225,11 @@ export type TypeSurfaceConfig = {
   typography: TSTypography;
   placement: TSPlacement;
   surface: TSSurface;
+  /**
+   * An object built from primitives (`construct.ts`). When set, it is what the text meets, and
+   * `surface.type` is ignored: the text wraps the part named in `object.text`.
+   */
+  object: TSObjectSpec | null;
   deformation: TSDeformation;
   material: TSMaterial;
   view: TSView;
@@ -229,7 +237,8 @@ export type TypeSurfaceConfig = {
 };
 
 type DeepPartial<T> = T extends (infer U)[] ? U[] : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
-export type TypeSurfaceConfigInput = DeepPartial<TypeSurfaceConfig>;
+/** Every field optional, except an `object`, which is given whole (its parts are a list). */
+export type TypeSurfaceConfigInput = Omit<DeepPartial<TypeSurfaceConfig>, 'object'> & { object?: TSObjectSpec | null };
 
 const FOLD_OFF: TSFold = { amount: 0, position: 0.5, angle: 180, width: 0.035, influence: 0.7, orientation: 'vertical', direction: 'over', side: 'far' };
 const WRAP_OFF: TSWrap = { amount: 0, position: 0.7, radius: 0.06, angle: 300, orientation: 'vertical', direction: 'under', side: 'far' };
@@ -259,6 +268,7 @@ export const DEFAULT_TYPE_SURFACE: TypeSurfaceConfig = {
   },
   placement: { x: 0.5, y: 0.34, rotation: 0, maxWidth: 900 },
   surface: { type: 'newspaper', state: 'flat', seed: 7, color: null },
+  object: null,
   deformation: { ...REST_DEFORMATION, wrap: 1 },
   material: {
     type: 'ink', blend: 0.75, inkStrength: 0.9, inkSpread: 0.35, inkRoughness: 0.4, paperInfluence: 0.75, grainInfluence: 0.5, halftone: 0,
@@ -408,7 +418,8 @@ export function setPath<T>(obj: T, path: string, value: unknown): T {
 function merge<T>(base: T, over: unknown): T {
   if (!isObj(base) || !isObj(over)) return (over === undefined ? base : over) as T;
   const out: Record<string, unknown> = { ...base };
-  for (const [k, v] of Object.entries(over)) out[k] = v === undefined ? out[k] : merge((base as Record<string, unknown>)[k], v);
+  // An object replaces the one before it: merging two part lists means nothing.
+  for (const [k, v] of Object.entries(over)) out[k] = v === undefined ? out[k] : k === 'object' ? v : merge((base as Record<string, unknown>)[k], v);
   return out as T;
 }
 
@@ -458,11 +469,18 @@ function checkStages(stages: unknown): TSConfigError[] {
 export function validateTypeSurface(config: unknown): TSConfigError[] {
   if (!isObj(config)) return [{ path: '', message: 'The config must be an object.' }];
   const errors: TSConfigError[] = [];
+  const built = config.object !== undefined && config.object !== null;
   for (const ctl of TS_CONTROLS) {
+    // `surface.type: 'object'` says the object is the surface; it needs one.
+    if (ctl.path === 'surface.type' && config.surface && (config.surface as Record<string, unknown>).type === 'object') {
+      if (!built) errors.push({ path: ctl.path, message: 'Surface is “object” but the config has no object.' });
+      continue;
+    }
     const msg = checkControl(ctl, getPath(config, ctl.path));
     if (msg) errors.push({ path: ctl.path, message: msg });
   }
   errors.push(...checkStages(getPath(config, 'animation.stages')));
+  if (built) errors.push(...sanitizeObject(config.object).errors);
   return errors;
 }
 
@@ -473,6 +491,14 @@ export function validateTypeSurface(config: unknown): TSConfigError[] {
 export function sanitizeTypeSurface(input: unknown): { config: TypeSurfaceConfig; invalid: string[] } {
   let config = resolveTypeSurface(isObj(input) ? (input as TypeSurfaceConfigInput) : {});
   const invalid: string[] = [];
+  // An object is repaired as a whole: numbers clamped, bad parts dropped, null if nothing can be drawn.
+  if (config.object !== null) {
+    const fixed = sanitizeObject(config.object);
+    if (fixed.errors.length) {
+      config = { ...config, object: fixed.object };
+      invalid.push(...fixed.errors.map((e) => e.path));
+    }
+  }
   for (const err of validateTypeSurface(config)) {
     if (err.path.startsWith('animation.stages')) {
       config = { ...config, animation: { ...config.animation, stages: [] } };