@mark1russell7/packing 0.2.11 → 0.2.13

package/src/registry.ts

@@ -1,16 +1,59 @@
 import { maxrects, push, rows, shelf, skyline } from "./adapters.ts";
+import { aspectFit } from "./aspect-fit.ts";
 import type { PackInput, PackOutput } from "./contract.ts";
 import { portfolioStrategy } from "./portfolio-strategy.ts";
-import { createContext, type Strategy } from "./strategy.ts";
+import { createContext, type PackContext, type Strategy, type Supports } from "./strategy.ts";
 
 /** Each single strategy of the package. The benchmark starts each one on each input of the corpus. */
 export const strategies: readonly Strategy[] = Object.freeze([rows, skyline, shelf, push, maxrects] as Strategy[]);
 
+/** The options of the strategy `aspect-fit` */
+export interface AspectFitStrategyOptions {
+  /** The id of the wrapped strategy of the registry. The option is necessary. */
+  strategy?: string;
+  /** The options of the wrapped strategy over its defaults */
+  options?: unknown;
+  /** The target aspect of `aspectFit`. The default is `aspect` of the container, else 1. */
+  targetAspect?: number;
+}
+
+/** This function gives the union of the supports of some strategies. */
+function unionOf(list: readonly Strategy[]): Supports {
+  const out: Record<string, string[]> = {};
+  for (const s of list) {
+    for (const [dim, values] of Object.entries(s.supports) as [string, string[]][]) {
+      const own = (out[dim] ??= []);
+      for (const v of values) if (!own.includes(v)) own.push(v);
+    }
+  }
+  return out as unknown as Supports;
+}
+
+/**
+ * The strategy `aspect-fit`: `aspectFit` of roadmap item k62 around the strategy of the option `strategy`. Its supports are
+ * the union of the supports of the single strategies. A cell that the wrapped strategy does not support throws its error.
+ * The strategy throws a `RangeError` without the option `strategy`.
+ */
+export const aspectFitStrategy: Strategy<AspectFitStrategyOptions> = {
+  id: "aspect-fit",
+  family: "aspect-fit",
+  catalog: [],
+  supports: unionOf(strategies),
+  defaults: {},
+  deterministic: true,
+  pack(input: PackInput, options: AspectFitStrategyOptions, context: PackContext): PackOutput {
+    if (options.strategy === undefined) throw new RangeError("The strategy aspect-fit needs the option strategy.");
+    const inner = strategy(options.strategy);
+    const merged: unknown = { ...(inner.defaults as object), ...(options.options as object | undefined) };
+    return aspectFit(inner, options.targetAspect === undefined ? {} : { targetAspect: options.targetAspect }).pack(input, merged, context);
+  },
+};
+
 /**
  * The composite strategies of the registry: each one packs an input with other strategies. They are not in `strategies`.
- * Since 0.2.7, the list has `portfolio` of roadmap item k20.
+ * Since 0.2.7, the list has `portfolio` of roadmap item k20. Roadmap item k62 adds `aspect-fit`.
  */
-export const composites: readonly Strategy[] = Object.freeze([portfolioStrategy] as Strategy[]);
+export const composites: readonly Strategy[] = Object.freeze([portfolioStrategy, aspectFitStrategy] as Strategy[]);
 
 /** This function gives the strategy with an id, also a composite strategy. It throws a `RangeError` for an id that the registry does not have. */
 export function strategy(id: string): Strategy {

package/src/select-key.ts

@@ -0,0 +1,48 @@
+// The key of a pick over the outputs of one input: the hard breaks, then some measures of `MEASURE_SPECS`, then the hash.
+// `packPortfolio` and `aspectFit` use it. The module is internal: the package root exports only `hardBreaks`.
+
+import type { PortfolioKey, SelectLevel } from "@mark1russell7/layout-contract";
+import { checkHard } from "./check.ts";
+import type { PackInput, PackOutput } from "./contract.ts";
+import { outputHash } from "./layout-input.ts";
+import { MEASURE_SPECS, measure, roundMeasures, type LayoutMeasures } from "./measures.ts";
+
+/** This function gives the count of the hard breaks of an output: the sum of `checkHard` with `exactContainer`. */
+export function hardBreaks(input: PackInput, output: PackOutput): number {
+  return Object.values(checkHard(input, output, undefined, { exactContainer: true })).reduce((sum, n) => sum + n, 0);
+}
+
+/** This function gives the level of a measure id with its spec of `MEASURE_SPECS`. It throws a `RangeError` for an unknown id. */
+export function measureLevel(id: string): SelectLevel {
+  const spec = (MEASURE_SPECS as Readonly<Record<string, SelectLevel["spec"] | undefined>>)[id];
+  if (spec === undefined || id === "hard") throw new RangeError(`A level of a key is a measure of MEASURE_SPECS, not "${id}".`);
+  return { id, spec };
+}
+
+/**
+ * This function makes the key of a pick: `hardBreaks`, then the measures of `levels` in order, then `outputHash`.
+ *
+ * - The levels read the measures after `roundMeasures`, as a record keeps them. A replay of the records gives the same pick.
+ * - The measures of one output are computed one time.
+ * - `view` gives the input of the measures. The default is the input. The hard breaks always read the input.
+ */
+export function measureKey(levels: readonly SelectLevel[], view: (input: PackInput) => PackInput = (input) => input): PortfolioKey<PackInput, PackOutput> {
+  const cache = new WeakMap<PackOutput, LayoutMeasures>();
+  const measured = (input: PackInput, output: PackOutput): LayoutMeasures => {
+    let m = cache.get(output);
+    if (m === undefined) {
+      m = roundMeasures(measure(view(input), output));
+      cache.set(output, m);
+    }
+    return m;
+  };
+  return {
+    hard: hardBreaks,
+    levels: levels.map((level) => ({
+      id: level.id,
+      spec: level.spec,
+      value: (input: PackInput, output: PackOutput): number => (measured(input, output) as unknown as Readonly<Record<string, number>>)[level.id]!,
+    })),
+    hash: outputHash,
+  };
+}