@multiplatform.one/theme 7.83.0 → 7.83.2

package/dist/cjs/theme/recipeInputs.cjs

@@ -0,0 +1,352 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var recipeInputs_exports = {};
+__export(recipeInputs_exports, {
+  DEFAULT_SIZE_RECIPE_INPUTS: () => DEFAULT_SIZE_RECIPE_INPUTS,
+  SIZE_RECIPE_RADIUS_STOPS: () => SIZE_RECIPE_RADIUS_STOPS,
+  SIZE_RECIPE_RADIUS_TOKEN_TO_STOP: () => SIZE_RECIPE_RADIUS_TOKEN_TO_STOP,
+  SIZE_RECIPE_TOKENS: () => import_scaleInputs2.SIZE_RECIPE_TOKENS,
+  SIZE_TOKEN_EXPONENTS: () => import_scaleInputs2.SIZE_TOKEN_EXPONENTS,
+  TOUCH_HEIGHT_FLOOR: () => TOUCH_HEIGHT_FLOOR,
+  applyRadiusStop: () => applyRadiusStop,
+  cloneSizeRecipeInputs: () => cloneSizeRecipeInputs,
+  createRecipeFamilies: () => createRecipeFamilies,
+  defaultRecipeInputs: () => defaultRecipeInputs,
+  generateSizeRecipeTables: () => generateSizeRecipeTables,
+  generateSizeRecipes: () => generateSizeRecipes,
+  mergeRecipeInputs: () => mergeRecipeInputs,
+  recipeFromTokenChannels: () => recipeFromTokenChannels,
+  recipeKeyAbove: () => recipeKeyAbove,
+  recipeKeyBelow: () => recipeKeyBelow,
+  resolveControlRadius: () => resolveControlRadius,
+  resolveSizeRecipeInputs: () => resolveSizeRecipeInputs,
+  sizeRecipeFromHeight: () => sizeRecipeFromHeight
+});
+module.exports = __toCommonJS(recipeInputs_exports);
+var import_activeScale = require("./scale/activeScale.cjs");
+var import_generateScale = require("./scale/generateScale.cjs");
+var import_scaleInputs = require("./scale/scaleInputs.cjs");
+var import_tileSizes = require("./tileSizes.cjs");
+var import_scaleInputs2 = require("./scale/scaleInputs.cjs");
+const defaultScale = (0, import_generateScale.generateScale)(import_scaleInputs.defaultScaleInputs);
+const SIZE_RECIPE_RADIUS_STOPS = {
+  none: defaultScale.tokens.radius[0],
+  small: defaultScale.tokens.radius[2],
+  medium: defaultScale.tokens.radius[4],
+  large: defaultScale.tokens.radius[6],
+  full: defaultScale.tokens.radius[12]
+};
+const DEFAULT_SIZE_RECIPE_INPUTS = defaultScale.recipeInputs;
+const defaultRecipeInputs = DEFAULT_SIZE_RECIPE_INPUTS;
+const TOUCH_HEIGHT_FLOOR = DEFAULT_SIZE_RECIPE_INPUTS.touchFloor;
+function mergeTokenTable(base, over) {
+  const next = {};
+  for (const token of import_scaleInputs.SIZE_RECIPE_TOKENS) {
+    const row = over?.[token] ?? (token === "$true" ? over?.$4 : void 0) ?? base[token];
+    if (row) next[token] = {
+      ...row
+    };
+  }
+  return next;
+}
+function mergeTokenHeights(base, over) {
+  const next = {
+    ...base,
+    ...over
+  };
+  if (over?.$4 != null && over.$true == null) next.$true = over.$4;
+  return next;
+}
+function cloneSizeRecipeInputs(inputs) {
+  return {
+    ...inputs,
+    tokenSteps: {
+      ...inputs.tokenSteps
+    },
+    tokenHeights: {
+      ...inputs.tokenHeights
+    },
+    tokenTable: mergeTokenTable(inputs.tokenTable),
+    chipTokenTable: mergeTokenTable(inputs.chipTokenTable),
+    inputPadX: {
+      ...inputs.inputPadX
+    },
+    ratios: {
+      ...inputs.ratios
+    },
+    chipRatios: {
+      ...inputs.chipRatios
+    },
+    tile: inputs.tile ? (0, import_tileSizes.cloneTileSizeInputs)(inputs.tile) : void 0
+  };
+}
+function resolveSizeRecipeInputs(partial = {}) {
+  const base = partial.control == null && partial.type == null ? DEFAULT_SIZE_RECIPE_INPUTS : (0, import_generateScale.generateScale)({
+    ...import_scaleInputs.defaultScaleInputs,
+    control: partial.control ?? DEFAULT_SIZE_RECIPE_INPUTS.control,
+    type: partial.type ?? DEFAULT_SIZE_RECIPE_INPUTS.type
+  }).recipeInputs;
+  const resolved = {
+    control: base.control,
+    type: base.type,
+    tokenSteps: {
+      ...base.tokenSteps,
+      ...partial.tokenSteps
+    },
+    tokenHeights: mergeTokenHeights(base.tokenHeights, partial.tokenHeights),
+    tokenTable: mergeTokenTable(base.tokenTable, partial.tokenTable),
+    chipTokenTable: mergeTokenTable(base.chipTokenTable, partial.chipTokenTable),
+    inputPadX: {
+      ...base.inputPadX,
+      ...partial.inputPadX
+    },
+    ratios: {
+      ...base.ratios,
+      ...partial.ratios
+    },
+    chipRatios: {
+      ...base.chipRatios,
+      ...partial.chipRatios
+    },
+    radiusPx: partial.radiusPx ?? base.radiusPx,
+    touchFloor: partial.touchFloor ?? base.touchFloor
+  };
+  if (partial.tile !== void 0) {
+    resolved.tile = partial.tile ? (0, import_tileSizes.resolveTileSizeInputs)(partial.tile) : void 0;
+  }
+  return resolved;
+}
+const mergeRecipeInputs = resolveSizeRecipeInputs;
+function clampHeight(value) {
+  return Math.max(1, Math.round(value));
+}
+function heightForToken(token, inputs) {
+  return clampHeight(inputs.tokenHeights[token] ?? inputs.control);
+}
+function sizeRecipeFromHeight(height, ratios = DEFAULT_SIZE_RECIPE_INPUTS.ratios) {
+  const gap = Math.round(height * ratios.gap);
+  return {
+    height,
+    paddingHorizontal: Math.round(height * ratios.padX),
+    fontSize: Math.round(height * ratios.font),
+    iconSize: Math.round(height * ratios.icon),
+    gap
+  };
+}
+function recipeFromTokenChannels(height, channels) {
+  return {
+    height,
+    paddingHorizontal: channels.paddingHorizontal,
+    fontSize: channels.fontSize,
+    iconSize: channels.iconSize,
+    gap: channels.radius
+  };
+}
+function applyRadiusStop(recipe, stop) {
+  return {
+    ...recipe,
+    gap: (0, import_activeScale.scaleRadiusPx)(SIZE_RECIPE_RADIUS_STOPS[stop])
+  };
+}
+const SIZE_RECIPE_RADIUS_TOKEN_TO_STOP = {
+  $0: "none",
+  $2: "small",
+  $4: "medium",
+  $6: "large",
+  $12: "full"
+};
+function resolveControlRadius(recipe, stop = "medium") {
+  if (stop === "medium") {
+    return {
+      radius: recipe.gap,
+      gap: recipe.gap
+    };
+  }
+  const px = (0, import_activeScale.scaleRadiusPx)(SIZE_RECIPE_RADIUS_STOPS[stop]);
+  return {
+    radius: px,
+    gap: recipe.gap
+  };
+}
+function generateTouchHeights(heights, inputs, tokens) {
+  const heightsTouch = {};
+  for (const token of tokens) {
+    heightsTouch[token] = Math.max(heights[token], inputs.touchFloor);
+  }
+  return heightsTouch;
+}
+function channelsForToken(token, table) {
+  if (!table) return void 0;
+  return table[token] ?? (token === "$true" ? table.$4 : void 0);
+}
+function generateSizeRecipeTables(inputs, ratios = inputs.ratios, table = inputs.tokenTable, heightOf = token => heightForToken(token, inputs)) {
+  const tokens = import_scaleInputs.SIZE_RECIPE_TOKENS;
+  const heights = {};
+  for (const token of tokens) {
+    heights[token] = heightOf(token);
+  }
+  if (inputs.tokenHeights.$true == null) {
+    heights.$true = heights.$4;
+  }
+  const touchHeights = generateTouchHeights(heights, inputs, tokens);
+  const recipes = {};
+  const recipesTouch = {};
+  const boxVariants = {};
+  const typeVariants = {};
+  const iconVariants = {};
+  const heightVariants = {};
+  const radii = {};
+  for (const token of tokens) {
+    const channels = channelsForToken(token, table);
+    const recipe = channels ? recipeFromTokenChannels(heights[token], channels) : sizeRecipeFromHeight(heights[token], ratios);
+    const radius = channels ? channels.radius : recipe.gap;
+    recipes[token] = recipe;
+    recipesTouch[token] = {
+      ...recipe,
+      height: touchHeights[token]
+    };
+    radii[token] = radius;
+    boxVariants[token] = {
+      height: recipe.height,
+      paddingHorizontal: recipe.paddingHorizontal,
+      gap: recipe.gap
+    };
+    typeVariants[token] = {
+      fontSize: recipe.fontSize
+    };
+    iconVariants[token] = {
+      width: recipe.iconSize,
+      height: recipe.iconSize
+    };
+    heightVariants[token] = {
+      height: recipe.height
+    };
+  }
+  return {
+    inputs,
+    ratios: {
+      ...ratios
+    },
+    heights,
+    touchHeights,
+    recipes,
+    recipesTouch,
+    boxVariants,
+    typeVariants,
+    iconVariants,
+    heightVariants,
+    radii
+  };
+}
+const RECIPE_LADDER = import_scaleInputs.SIZE_RECIPE_TOKENS.filter(token => token !== "$true");
+function recipeKeyBelow(token) {
+  const index = RECIPE_LADDER.indexOf(token === "$true" ? "$4" : token);
+  return RECIPE_LADDER[Math.max(0, index - 1)];
+}
+function recipeKeyAbove(token) {
+  const index = RECIPE_LADDER.indexOf(token === "$true" ? "$4" : token);
+  return RECIPE_LADDER[Math.min(RECIPE_LADDER.length - 1, index + 1)];
+}
+function ratiosOf(table, height) {
+  const row = table.$4;
+  if (!row) return {
+    padX: 0,
+    font: 0,
+    icon: 0,
+    gap: 0
+  };
+  return {
+    padX: row.paddingHorizontal / height,
+    font: row.fontSize / height,
+    icon: row.iconSize / height,
+    gap: row.radius / height
+  };
+}
+function deriveRowFamilyTables(inputs) {
+  const menuRow = {};
+  const tab = {};
+  const rowPadX = inputs.tokenTable.$3?.paddingHorizontal;
+  for (const token of import_scaleInputs.SIZE_RECIPE_TOKENS) {
+    const own = channelsForToken(token, inputs.tokenTable);
+    const below = channelsForToken(recipeKeyBelow(token), inputs.tokenTable);
+    if (!own || !below) continue;
+    menuRow[token] = {
+      ...own,
+      paddingHorizontal: rowPadX ?? below.paddingHorizontal
+    };
+    tab[token] = {
+      ...own,
+      paddingHorizontal: below.paddingHorizontal
+    };
+  }
+  return {
+    menuRow,
+    tab
+  };
+}
+function createRecipeFamilies(inputs = {}) {
+  const resolved = cloneSizeRecipeInputs(resolveSizeRecipeInputs(inputs));
+  const control = generateSizeRecipeTables(resolved, resolved.ratios, resolved.tokenTable);
+  const chip = generateSizeRecipeTables(resolved, resolved.chipRatios, resolved.chipTokenTable);
+  const rows = deriveRowFamilyTables(resolved);
+  const heightBelow = token => heightForToken(recipeKeyBelow(token), resolved);
+  const rowHeight = heightBelow("$4");
+  const menuRow = generateSizeRecipeTables(resolved, ratiosOf(rows.menuRow, rowHeight), rows.menuRow, heightBelow);
+  const tab = generateSizeRecipeTables(resolved, ratiosOf(rows.tab, rowHeight), rows.tab, heightBelow);
+  return {
+    control: {
+      ...control,
+      name: "control"
+    },
+    chip: {
+      ...chip,
+      name: "chip"
+    },
+    menuRow: {
+      ...menuRow,
+      name: "menuRow"
+    },
+    tab: {
+      ...tab,
+      name: "tab"
+    }
+  };
+}
+function generateSizeRecipes(partial = {}) {
+  const inputs = cloneSizeRecipeInputs(resolveSizeRecipeInputs(partial));
+  const families = createRecipeFamilies(inputs);
+  const control = families.control;
+  return {
+    inputs,
+    heights: control.heights,
+    heightsTouch: control.touchHeights,
+    recipes: control.recipes,
+    recipesTouch: control.recipesTouch,
+    boxVariants: control.boxVariants,
+    typeVariants: control.typeVariants,
+    iconVariants: control.iconVariants,
+    radii: control.radii,
+    families,
+    tiles: (0, import_tileSizes.generateTileSizeLadder)((0, import_tileSizes.resolveTileSizeInputs)(inputs.tile ?? {}))
+  };
+}