@mark1russell7/strategy-space 0.0.0-stage → 0.0.2

package/build/terms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terms.js","names":[],"sources":["../src/terms.ts"],"sourcesContent":["// The combinators of a strategy space (`docs/OPERATORS.md`): terms over configs, and the count of the terms to a depth.\nimport { canonicalJson } from \"@mark1russell7/rigor-generators\";\nimport type { ClaimBreak } from \"./claim.ts\";\nimport { checkConfig, spaceSize, type ShapeFilter, type StrategyConfig, type StrategySpace } from \"./strategy-space.ts\";\n\n/** The declaration of a combinator: a term with a range of arguments. */\nexport interface Combinator {\n  readonly name: string;\n  /** The smallest count of the arguments, a whole number of 1 or more. */\n  readonly min: number;\n  /** The largest count of the arguments, a whole number of `min` or more. */\n  readonly max: number;\n  /** With `true`, the order of the arguments changes the term. */\n  readonly ordered: boolean;\n  /** With `true`, the arguments of a term are all different. */\n  readonly distinct: boolean;\n  /**\n   * The spec of a term of this combinator. With no value, a term has no spec.\n   * `object`: the term has a spec object, for example the rule that picks the best result of a portfolio.\n   * `limits`: the spec is `{ measure, limits }`. The limits are increasing numbers, one fewer than the arguments.\n   */\n  readonly spec?: \"object\" | \"limits\";\n  /** The text that tells what the term does with its arguments. */\n  readonly summary: string;\n}\n\n/**\n * The combinators of the first format. A term of `product` takes a pack config and a route config, and a joint space joins them.\n * A tie of a `portfolio` goes to the first argument in the order of `canonicalTerm`. So the order of the arguments does not change the result.\n */\nexport const COMBINATORS: readonly Combinator[] = /* @__PURE__ */ Object.freeze([\n  {\n    name: \"portfolio\",\n    min: 2,\n    max: 16,\n    ordered: false,\n    distinct: true,\n    spec: \"object\",\n    summary: \"It gives the input to each argument, and keeps the best result by the pick rule of its spec. A tie goes to the first argument in the canonical order.\",\n  },\n  { name: \"sequence\", min: 2, max: 2, ordered: true, distinct: false, summary: \"It gives the result of the first argument to the second argument.\" },\n  { name: \"fallback\", min: 2, max: 2, ordered: true, distinct: true, summary: \"It gives the result of the first argument. When the first argument refuses the input, it gives the result of the second argument.\" },\n  {\n    name: \"dispatch\",\n    min: 2,\n    max: 16,\n    ordered: true,\n    distinct: false,\n    spec: \"limits\",\n    summary: \"It reads one measure of the input. At or below the first limit, it gives the result of the first argument, and so on up the limits.\",\n  },\n]);\n\n/**\n * The starts of the keys that a spec can not have at any depth, with case ignored, for example `budgetMs` or `timeoutMs`.\n * A time budget makes the result change with the speed of the computer. A key that ends with `work`, for example `budgetWork`, is a count of steps, so a spec can have it.\n */\nexport const BUDGET_KEYS: readonly string[] = /* @__PURE__ */ Object.freeze([\"budget\", \"deadline\", \"timeout\"]);\n\n/**\n * This function gives the index of the argument of a `dispatch` term for a value of its measure. A band includes its upper limit.\n * So the value `limits[i]` goes to the argument `i`, and a value above the last limit goes to the last argument.\n */\nexport function dispatchIndex(limits: readonly number[], value: number): number {\n  if (Number.isNaN(value)) throw new RangeError(\"The value of the measure is NaN.\");\n  const i = limits.findIndex((limit) => value <= limit);\n  return i === -1 ? limits.length : i;\n}\n\n/** A term: a config of the space, or a combinator with its arguments. */\nexport type StrategyTerm =\n  | { readonly config: StrategyConfig }\n  | { readonly combinator: string; readonly args: readonly StrategyTerm[]; readonly spec?: Readonly<Record<string, unknown>> };\n\n/** The options of `countSpace`. */\nexport interface CountOptions extends ShapeFilter {\n  /** The largest depth of a term. A config has the depth 0. A term has the depth 1 more than its deepest argument. */\n  readonly depth: number;\n  /** The count of the levels of each numeric param of the space. */\n  readonly levels: number;\n  /** The combinators. The default is `COMBINATORS`. */\n  readonly combinators?: readonly Combinator[];\n  /**\n   * The count of the specs of a term of each combinator, by its name. A list gives a count for each count of arguments, from `min` to `max`.\n   * The default is 1. A `dispatch` term with `m` arguments has the count of its measures times the count of the lists of `m - 1` limits.\n   */\n  readonly specs?: Readonly<Record<string, bigint | readonly bigint[]>>;\n}\n\n/** The count of the terms of a space. */\nexport interface TermCount {\n  /** The count of the configs without a meta option, the terms of the depth 0. */\n  readonly base: bigint;\n  /** The item `k` is the count of the terms of a depth of `k` or less. */\n  readonly upTo: readonly bigint[];\n  /** The count of the terms of a depth of `depth` or less. */\n  readonly total: bigint;\n}\n\n/** This function throws a `RangeError` for a value that is not a whole number of `min` or more. */\nfunction assertWhole(value: number, name: string, min: number): void {\n  if (!Number.isInteger(value) || value < min) throw new RangeError(`The ${name} ${value} is not a whole number of ${min} or more.`);\n}\n\n/** This function gives the breaks of a list of combinators. The claims are `combinator`, `duplicate` and `arity`. */\nexport function checkCombinators(combinators: readonly Combinator[]): ClaimBreak[] {\n  const out: ClaimBreak[] = [];\n  const names = new Set<string>();\n  for (const c of combinators) {\n    if (typeof c.name !== \"string\" || c.name === \"\") out.push({ claim: \"combinator\", detail: \"a combinator has no name\", inputs: [] });\n    else if (names.has(c.name)) out.push({ claim: \"duplicate\", detail: `the list has the combinator ${c.name} two times`, inputs: [c.name] });\n    names.add(c.name);\n    if (!Number.isInteger(c.min) || c.min < 1 || !Number.isInteger(c.max) || c.max < c.min)\n      out.push({ claim: \"arity\", detail: `the combinator ${c.name} has the arity ${c.min} to ${c.max}, not whole numbers with 1 <= min <= max`, inputs: [c.name] });\n  }\n  return out;\n}\n\n/** This function gives the count of the specs of one combinator for each count of arguments, from `min` to `max`. */\nfunction specCounts(c: Combinator, specs: CountOptions[\"specs\"]): bigint[] {\n  const given = specs?.[c.name];\n  const width = c.max - c.min + 1;\n  const counts = given === undefined ? Array<bigint>(width).fill(1n) : typeof given === \"bigint\" ? Array<bigint>(width).fill(given) : [...given];\n  if (counts.length !== width || counts.some((x) => typeof x !== \"bigint\" || x < 0n))\n    throw new RangeError(`The specs of ${c.name} are not ${width} whole numbers of 0 or more.`);\n  return counts;\n}\n\n/** This function gives the count of the terms of one combinator over a pool of `n` terms: the argument lists times the specs. */\nfunction argumentLists(c: Combinator, n: bigint, specs: readonly bigint[]): bigint {\n  let sum = 0n;\n  for (let m = c.min; m <= c.max; m++) {\n    const k = BigInt(m);\n    let lists: bigint;\n    if (c.ordered && c.distinct) lists = fallingFactorial(n, k);\n    else if (c.ordered) lists = n ** k;\n    else if (c.distinct) lists = fallingFactorial(n, k) / factorial(k);\n    else lists = fallingFactorial(n + k - 1n, k) / factorial(k);\n    sum += lists * specs[m - c.min]!;\n  }\n  return sum;\n}\n\nfunction fallingFactorial(n: bigint, k: bigint): bigint {\n  if (k > n) return 0n;\n  let out = 1n;\n  for (let i = 0n; i < k; i++) out *= n - i;\n  return out;\n}\n\nfunction factorial(k: bigint): bigint {\n  let out = 1n;\n  for (let i = 2n; i <= k; i++) out *= i;\n  return out;\n}\n\n/**\n * This function gives the count of the terms of a space to a depth. The base is the count of the configs without a meta option.\n * The terms of a depth of `k - 1` or less give the argument lists of each combinator. Each list counts once for each spec.\n * The count of a depth of `k` or less is the base plus these terms. Two terms with a different tree count as two terms, also when they give the same layout.\n */\nexport function countSpace(space: StrategySpace, options: CountOptions): TermCount {\n  assertWhole(options.depth, \"depth\", 0);\n  const combinators = options.combinators ?? COMBINATORS;\n  const breaks = checkCombinators(combinators);\n  if (breaks.length > 0) throw new RangeError(`The combinators are not good: ${breaks.map((b) => b.detail).join(\"; \")}.`);\n  // The meta count is not part of a term count, so maxMeta 0 stops it early.\n  const filter = { ...(options.shapes === undefined ? {} : { shapes: options.shapes }), ...(options.kinds === undefined ? {} : { kinds: options.kinds }) };\n  const base = spaceSize(space, { levels: options.levels, maxMeta: 0n, ...filter }).base;\n  const specs = combinators.map((c) => specCounts(c, options.specs));\n  const upTo: bigint[] = [base];\n  for (let k = 1; k <= options.depth; k++) {\n    const pool = upTo[k - 1]!;\n    upTo.push(combinators.reduce((sum, c, i) => sum + argumentLists(c, pool, specs[i]!), base));\n  }\n  return { base, upTo, total: upTo[options.depth]! };\n}\n\n/** This function gives the depth of a term. A config has the depth 0. */\nexport function termDepth(term: StrategyTerm): number {\n  return \"config\" in term ? 0 : 1 + Math.max(0, ...term.args.map(termDepth));\n}\n\n/** This function gives the path of the first key that starts with a key of `BUDGET_KEYS`, or `undefined` when the value has none. */\nfunction budgetKey(value: unknown, path: string): string | undefined {\n  if (value === null || typeof value !== \"object\") return undefined;\n  for (const [key, inner] of Object.entries(value)) {\n    const at = path === \"\" ? key : `${path}.${key}`;\n    const lower = key.toLowerCase();\n    if (BUDGET_KEYS.some((start) => lower.startsWith(start)) && !lower.endsWith(\"work\")) return at;\n    const found = budgetKey(inner, at);\n    if (found !== undefined) return found;\n  }\n  return undefined;\n}\n\n/** This function gives the breaks of the spec of a term of the combinator `c`. */\nfunction specBreaks(c: Combinator, t: { readonly args: readonly StrategyTerm[]; readonly spec?: unknown }, at: string): string[] {\n  const spec = t.spec;\n  const isObject = spec !== null && typeof spec === \"object\" && !Array.isArray(spec);\n  if (c.spec === undefined) return spec === undefined ? [] : [`the term ${c.name} at ${at} has a spec, but ${c.name} takes no spec`];\n  if (!isObject) return [`the term ${c.name} at ${at} has no spec object`];\n  if (c.spec === \"object\") return [];\n  const { measure, limits } = spec as { measure?: unknown; limits?: unknown };\n  const out: string[] = [];\n  if (typeof measure !== \"string\" || measure === \"\") out.push(`the term ${c.name} at ${at} has no measure`);\n  const good =\n    Array.isArray(limits) &&\n    limits.length === t.args.length - 1 &&\n    limits.every((x, i) => typeof x === \"number\" && Number.isFinite(x) && (i === 0 || x > (limits[i - 1] as number)));\n  if (!good) out.push(`the term ${c.name} at ${at} needs ${t.args.length - 1} increasing finite limits`);\n  return out;\n}\n\n/**\n * This function gives the breaks of a term. The claims are the claims of `checkConfig` for each config, and `combinator`, `arity`, `distinct`, `spec` and `budget`.\n * The `inputs` of a break have the path of the term, for example `0.1` for the second argument of the first argument. The root has the path `\"\"`.\n */\nexport function checkTerm(space: StrategySpace, term: StrategyTerm, combinators: readonly Combinator[] = COMBINATORS): ClaimBreak[] {\n  const out: ClaimBreak[] = [];\n  const walk = (t: StrategyTerm, path: string): void => {\n    const at = path === \"\" ? \"the root\" : path;\n    if (\"config\" in t) {\n      for (const b of checkConfig(space, t.config)) out.push({ claim: b.claim, detail: `the config at ${at}: ${b.detail}`, inputs: [path] });\n      return;\n    }\n    const c = combinators.find((x) => x.name === t.combinator);\n    if (c === undefined) out.push({ claim: \"combinator\", detail: `the term at ${at} has the unknown combinator ${JSON.stringify(t.combinator)}`, inputs: [path] });\n    else if (t.args.length < c.min || t.args.length > c.max)\n      out.push({ claim: \"arity\", detail: `the term ${c.name} at ${at} has ${t.args.length} arguments, not ${c.min} to ${c.max}`, inputs: [path] });\n    if (c !== undefined) for (const detail of specBreaks(c, t, at)) out.push({ claim: \"spec\", detail, inputs: [path] });\n    const budget = budgetKey(t.spec, \"\");\n    if (budget !== undefined) out.push({ claim: \"budget\", detail: `the spec at ${at} has the time budget ${budget}, so the term is not deterministic`, inputs: [path] });\n    if (c?.distinct === true) {\n      const keys = t.args.map((a) => canonicalJson(a, { form: \"json\" }));\n      if (new Set(keys).size !== keys.length) out.push({ claim: \"distinct\", detail: `the term ${c.name} at ${at} has the same argument two times`, inputs: [path] });\n    }\n    t.args.forEach((a, i) => walk(a, path === \"\" ? String(i) : `${path}.${i}`));\n  };\n  walk(term, \"\");\n  return out;\n}\n\n/**\n * This function gives the canonical form of a term. It sorts the arguments of each term of an unordered combinator by their canonical JSON.\n * Two terms that differ only in the order of such arguments give the same form. A tie of a `portfolio` goes to the first argument of this form.\n */\nexport function canonicalTerm(term: StrategyTerm, combinators: readonly Combinator[] = COMBINATORS): StrategyTerm {\n  if (\"config\" in term) return term;\n  const args = term.args.map((a) => canonicalTerm(a, combinators));\n  const c = combinators.find((x) => x.name === term.combinator);\n  if (c !== undefined && !c.ordered) {\n    const keyed = args.map((a) => [canonicalJson(a, { form: \"json\" }), a] as const);\n    keyed.sort(([x], [y]) => (x < y ? -1 : x > y ? 1 : 0));\n    return { ...term, args: keyed.map(([, a]) => a) };\n  }\n  return { ...term, args };\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,63 @@
 {
+  "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/strategy-space",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.2",
+  "description": "Layout strategies as data: the stages, options and parameters of a space, its checks, the id of a config, the count of the space, grids and seeded samples.",
+  "keywords": [
+    "strategy-space",
+    "layout",
+    "configuration-space",
+    "enumeration",
+    "sampling",
+    "search-space",
+    "deterministic"
+  ],
+  "homepage": "https://github.com/mark1russell7/strategy-space/tree/main/packages/strategy-space#readme",
+  "bugs": {
+    "url": "https://github.com/mark1russell7/strategy-space/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mark1russell7/strategy-space.git",
+    "directory": "packages/strategy-space"
+  },
+  "license": "MIT",
+  "author": "Mark Russell (https://github.com/mark1russell7)",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./build/index.js",
+  "files": [
+    "build"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@mark1russell7/rigor-generators": "^0.1.7"
+  },
+  "devDependencies": {
+    "@mark1russell7/cue": "^2.0.0",
+    "@types/node": "^26.6.5",
+    "esbuild": "^0.28.2",
+    "tsdown": "^0.23.1",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.test.json"
+  },
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "import": "./build/index.js"
+    },
+    "./package.json": "./package.json"
+  }
 }