@ahoo-wang/wow-view-engine 9.2.0-rc.0

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.js","names":["dayjs","RecordData","valueAt","document","path","split","reduce","held","segment","undefined","instantOf","at","Number","isFinite","parsed","valueOf","numberOf","value","Array","isArray","length","typeRank","compareValues","left","right","ranks","a","b","JSON","stringify","mod","by","AggregationDatePart","AggregationDateUnit","DateHistogramAggregationGroup","DatePartAggregationGroup","mod","HOUR_MS","DAY_MS","SUB_DAY_WIDTHS","Partial","Record","HOUR","MINUTE","SECOND","LocalDay","start","end","bucket","regular","bucketers","Map","at","bucketerOf","unit","zone","key","bucketer","get","newBucketer","set","Object","values","includes","Error","clock","wallClock","days","dayOf","known","Math","floor","find","day","localDay","last","index","held","push","width","undefined","wall","WallClock","instant","clocks","format","Intl","DateTimeFormat","timeZone","hourCycle","year","month","hour","minute","second","era","parts","type","value","formatToParts","Number","date","Date","setUTCFullYear","setUTCHours","getTime","local","instantAt","before","after","named","filter","sort","left","right","dayBucket","getUTCFullYear","getUTCMonth","first","monthIndex","midnight","WEEK","getUTCDay","MONTH","QUARTER","YEAR","zoneOf","group","PART_DOMAINS","DAY_OF_WEEK","HOUR_OF_DAY","DAY_OF_MONTH","MONTH_OF_YEAR","parterOf","part","getUTCHours","getUTCDate","MAX_DENSE_BUCKETS","NEXT_BUCKET","step","DAY","denseKeys","keys","length","sorted","bucketOf","answer","probe","AggregationExpressionOperator","AggregationExpressionType","DateDiffUnit","AggregationExpression","instantOf","numberOf","valueAt","DATE_DIFF_MS","Record","SECOND","MINUTE","HOUR","DAY","arithmetic","operator","left","right","ADD","SUBTRACT","MULTIPLY","DIVIDE","Error","String","evaluated","expression","record","finite","value","Number","isFinite","type","FIELD","field","CONSTANT","BINARY","DATE_DIFF","unit","undefined","from","to","Query","AnyObject","ComparisonOperator","DeletionState","FilterOperator","SearchMode","StringComparison","TimeUnit","ElementFilterExpression","FilterExpression","NowFilter","RecordData","evaluated","Filter","matches","document","filter","options","now","criteria","atNow","test","compares","operator","value","against","EQ","NE","GT","GTE","LT","LTE","Error","String","withDeletionDefault","mentionsDeletion","$and","deleted","$ne","op","DELETION","AND","OR","NOR","operands","some","escape","text","replace","MATCH_ALL","MATCH_NONE","$nor","EXPRESSION","expression","comparison","$where","this","computed","toLowerCase","map","field","BETWEEN","$gte","lowerBound","$lte","upperBound","IN","$in","values","NOT_IN","$nin","CONTAINS_ALL","$all","AGGREGATE_ID","aggregateId","$eq","AGGREGATE_IDS","OWNER_ID","ownerId","CONTAINS","STARTS_WITH","ENDS_WITH","pattern","flags","stringComparison","CASE_INSENSITIVE","RegExp","IS_EMPTY","$size","IS_NULL","IS_NOT_NULL","IS_EMPTY_STRING","IS_NOT_EMPTY_STRING","EXISTS","$exists","NOT_EXISTS","state","ALL","DELETED","SEARCH","fields","length","words","mode","PHRASE","query","trim","split","$or","flatMap","word","ELEMENT_MATCH","$elemMatch","predicate","Q","clock","Date","lower","node","Array","isArray","BEFORE_NOW","AFTER_NOW","nowComparison","Object","fromEntries","entries","key","PER_MILLISECOND","Record","NANOSECONDS","MICROSECONDS","MILLISECONDS","SECONDS","MINUTES","HOURS","DAYS","datePattern","undefined","moment","durationMs","offset","unit","timeUnit","Math","trunc","DURATION","match","exec","slice","every","part","sign","days","hours","minutes","seconds","fraction","fractionMs","Number","startsWith","ms","Query","find","AGGREGATION_LIMITS","AggregationExpressionType","AggregationFunction","AggregationGroupType","AggregationMetricType","DerivedExpressionType","HavingExpressionType","SortDirection","AggregationGroup","AggregationMetric","AggregationQuery","DateHistogramAggregationGroup","DatePartAggregationGroup","DerivedExpression","FieldSort","HavingExpression","PART_DOMAINS","bucketerOf","denseKeys","parterOf","zoneOf","arithmetic","evaluated","compares","criteria","compareValues","instantOf","numberOf","valueAt","RecordData","summarise","matched","query","units","expand","groupBy","dense","denseGroup","metrics","filter","metric","type","DERIVED","gates","map","undefined","keyers","keyerOf","groups","Map","keys","length","set","denseAt","indexOf","unit","keyOf","id","JSON","stringify","group","get","push","rows","values","members","rowOf","filled","row","withDerived","having","keeps","sorted","sort","slice","limit","DEFAULT_LIMIT","scope","element","elements","flatMap","record","items","path","Array","isArray","item","all","DATE_HISTOGRAM","DATE_PART","Error","TERMS","field","expression","missingKey","value","HISTOGRAM","interval","Number","isFinite","Math","floor","bucketOf","at","partOf","part","forEach","index","alias","gate","metricOf","test","COUNT","NUMERIC","PERCENTILE","function","MIN","MAX","FIELD","extremeOf","percentileOf","percentile","numericOf","DISTINCT_COUNT","seen","Set","each","add","size","ANY","best","FIRST","LAST","first","orderBy","greatest","raw","by","fn","sum","reduce","total","mean","answer","SUM","AVG","min","max","STDDEV","VARIANCE","variance","sqrt","String","left","right","rank","below","above","emptyValues","Object","fromEntries","byKey","last","from","_","key","derive","CONSTANT","METRIC_REF","BINARY","operator","numberAt","AND","operands","every","operand","OR","some","CONDITION","BETWEEN","lower","upper","IN","includes","IS_NULL","negated","named","order","direction","sign","DESC","has","find","DEFAULT_PAGINATION","FilterOperator","SortDirection","AggregationQuery","FieldSort","FilterExpression","RecordData","ViewSource","summarise","atNow","withDeletionDefault","valueAt","MemorySourceOptions","now","timeField","remember","MEMO_LIMIT","memorySource","documents","options","table","tableOf","answers","Map","clock","paged","asked","settled","query","matched","matchedIn","filter","sort","index","size","pagination","start","total","length","list","slice","map","projected","cursor","Number","end","nextCursor","String","aggregate","aggregateOver","key","JSON","stringify","answer","get","clear","set","structuredClone","work","T","Promise","resolve","Table","op","MATCH_ALL","times","Float64Array","undefined","timed","document","at","isFinite","Error","left","right","from","scoped","sortSpec","all","Record","Object","fromEntries","field","direction","DESC","projection","include","spec","path","to","condition","conjuncts","GT","GTE","LT","LTE","EQ","value","Math","max","firstAt","min","BETWEEN","lowerBound","upperBound","AND","operands","flatMap","after","low","high","middle","QueryModelDescriptor","DEFAULT_RUNTIME_LIMITS","Issue","RuntimeLimits","ViewDefinition","builtinFieldKinds","issue","FieldKindRegistry","narrowDefinition","sayDefinition","validateDefinition","Admissible","definition","AdmitOptions","text","key","kinds","limits","Partial","AdmitFinding","admit","definitions","descriptors","Readonly","Record","options","said","map","entry","findings","Map","declared","id","set","kind","descriptor","source","get","push","flatMap","found","FieldOption","RecordKey","actionState","choiceOf","confirmOf","asksFirst","initialInput","missingInput","nextChange","offeredAt","refusalsByReason","runOne","splitFor","ActionConfirm","ActionInput","ActionPlace","ActionRefusal","ActionRow","RecordRow","RecordAction","RecordActions","ActionHarnessOptions","now","HarnessState","hidden","available","reason","HarnessBulk","able","refused","reasons","count","keys","HarnessField","name","label","input","options","required","ActionHarness","ids","at","place","state","id","key","bulk","asks","confirm","form","choice","missing","changesAt","run","Promise","actionHarness","list","rows","Date","byKey","Map","map","row","find","action","each","Error","pressed","rowOf","get","String","split","length","given","Object","entries","field","undefined","builtinFieldKinds","DEFAULT_RUNTIME_LIMITS","splitFor","asksFirst","issue","initialInput","missingInput","runOne","refusalsByReason","offeredAt","ActionRefusedError","narrowDefinition","actionState","nextChange","confirmOf","validateDefinition","sayDefinition","resolveNavigation","dayjs","valueAt","path","held","segment","document","instantOf","at","parsed","numberOf","value","typeRank","compareValues","ranks","left","right","a","b","mod","by","HOUR_MS","DAY_MS","SUB_DAY_WIDTHS","AggregationDateUnit","bucketers","bucketerOf","key","unit","zone","bucketer","newBucketer","clock","wallClock","days","dayOf","known","day","localDay","last","index","width","clocks","format","wall","parts","type","year","date","instantAt","local","before","after","start","end","dayBucket","month","first","midnight","monthIndex","zoneOf","group","PART_DOMAINS","AggregationDatePart","parterOf","part","MAX_DENSE_BUCKETS","NEXT_BUCKET","denseKeys","keys","sorted","bucketOf","step","answer","probe","DATE_DIFF_MS","DateDiffUnit","arithmetic","operator","AggregationExpressionOperator","evaluated","finite","expression","AggregationExpressionType","record","from","to","matches","Query","criteria","atNow","filter","options","compares","ComparisonOperator","against","withDeletionDefault","mentionsDeletion","FilterOperator","escape","text","computed","comparison","pattern","flags","StringComparison","DeletionState","words","SearchMode","field","word","now","lower","node","op","nowComparison","query","PER_MILLISECOND","TimeUnit","moment","durationMs","DURATION","match","sign","hours","minutes","seconds","fraction","fractionMs","ms","summarise","units","expand","matched","groupBy","dense","denseGroup","metrics","metric","AggregationMetricType","gates","keyers","keyerOf","groups","denseAt","keyOf","id","rows","members","rowOf","filled","withDerived","row","keeps","AGGREGATION_LIMITS","scope","element","items","item","find","AggregationGroupType","missingKey","interval","partOf","gate","metricOf","AggregationFunction","extremeOf","values","percentileOf","numericOf","seen","each","best","raw","greatest","sum","total","mean","fn","variance","rank","percentile","below","above","emptyValues","byKey","derive","DerivedExpressionType","numberAt","having","HavingExpressionType","operand","named","sort","order","direction","SortDirection","alias","MEMO_LIMIT","memorySource","table","tableOf","documents","answers","settled","asked","matchedIn","DEFAULT_PAGINATION","size","projected","aggregateOver","resolve","work","timeField","timed","cursor","scoped","sortSpec","include","spec","times","condition","conjuncts","firstAt","lowerBound","upperBound","low","high","middle","admit","kinds","limits","said","definitions","entry","findings","declared","definition","descriptor","descriptors","found","actionHarness","action","list","pressed","input","place","split","given","form","name","choiceOf"],"sources":["../src/testing/values.ts","../src/testing/calendar.ts","../src/testing/expression.ts","../src/testing/filter.ts","../src/testing/aggregate.ts","../src/testing/source.ts","../src/runtime/admission.ts","../src/testing/actions.ts"],"sourcesContent":["/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport dayjs from 'dayjs';\nimport type { RecordData } from '../model/record.js';\n\n/** A field of a document by its dotted path; `undefined` where the path ends early. */\nexport function valueAt(document: unknown, path: string): unknown {\n  return path\n    .split('.')\n    .reduce<unknown>(\n      (held, segment) =>\n        held !== null && typeof held === 'object'\n          ? (held as RecordData)[segment]\n          : undefined,\n      document,\n    );\n}\n\n/** A time as epoch milliseconds, or `null` for what names no instant. */\nexport function instantOf(at: unknown): number | null {\n  if (typeof at === 'number') return Number.isFinite(at) ? at : null;\n  if (typeof at !== 'string') return null;\n  const parsed = dayjs(at).valueOf();\n  return Number.isFinite(parsed) ? parsed : null;\n}\n\n/**\n * The number a metric reads off one value, as `wow-mongo` reads it: a finite\n * number, or the one number of an array that holds exactly one — an array of\n * several is no number; null for anything else.\n */\nexport function numberOf(value: unknown): number | null {\n  if (Array.isArray(value))\n    return value.length === 1 ? numberOf(value[0]) : null;\n  return typeof value === 'number' && Number.isFinite(value) ? value : null;\n}\n\n/** MongoDB's order of the BSON types a JSON document holds: null first. */\nfunction typeRank(value: unknown): number {\n  if (value === null || value === undefined) return 0;\n  if (typeof value === 'number') return 1;\n  if (typeof value === 'string') return 2;\n  if (Array.isArray(value)) return 4;\n  if (typeof value === 'object') return 3;\n  return 5;\n}\n\n/** Two values in MongoDB's order, which is the one `ANY`'s `$max` reads. */\nexport function compareValues(left: unknown, right: unknown): number {\n  const ranks = typeRank(left) - typeRank(right);\n  if (ranks !== 0) return ranks;\n  const [a, b] =\n    typeof left === 'number' ||\n    typeof left === 'string' ||\n    typeof left === 'boolean'\n      ? [left, right as typeof left]\n      : [JSON.stringify(left), JSON.stringify(right)];\n  return a < b ? -1 : a > b ? 1 : 0;\n}\n\nexport function mod(value: number, by: number): number {\n  return ((value % by) + by) % by;\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  AggregationDatePart,\n  AggregationDateUnit,\n  type DateHistogramAggregationGroup,\n  type DatePartAggregationGroup,\n} from '@ahoo-wang/wow-client';\nimport { mod } from './values.js';\n\nconst HOUR_MS = 3_600_000;\nconst DAY_MS = 24 * HOUR_MS;\n\n/**\n * The units a bucket shorter than a day is cut at, in milliseconds. Inside a\n * local day the clock does not jump on, such a bucket is a slot of this width\n * counted from local midnight — the wall-clock hour, minute or second, which\n * is what Wow keys a sub-day bucket by in any zone, a half-hour one too.\n */\nconst SUB_DAY_WIDTHS: Partial<Record<AggregationDateUnit, number>> = {\n  [AggregationDateUnit.HOUR]: HOUR_MS,\n  [AggregationDateUnit.MINUTE]: 60_000,\n  [AggregationDateUnit.SECOND]: 1_000,\n};\n\n/** One calendar day in a zone: `[start, end)` and the bucket it falls in. */\ninterface LocalDay {\n  start: number;\n  end: number;\n  /** The day's bucket, for a unit of a day or more. */\n  bucket: number;\n  /** A day of 24 hours the zone's offset does not change during. */\n  regular: boolean;\n}\n\n/**\n * The bucket start of each instant, per (unit, zone), shared by every\n * source: it is a function of the calendar alone, so a bucketer built for one\n * source's documents is right for any other's.\n */\nconst bucketers = new Map<string, (at: number) => number>();\n\n/**\n * The bucket start an instant falls in, for one unit in one zone: the start\n * of its unit in the zone, in epoch milliseconds, which is the key the\n * service answers a date bucket with.\n *\n * Every bucket of a day or more starts at a local midnight, so the bucket is\n * a property of the calendar day: it is worked out once per day the rows\n * touch and looked up after that, where converting each row into the zone\n * cost a conversion per row per query. A shorter bucket is counted from the\n * day's start (`SUB_DAY_WIDTHS`), except on a day the clock jumps, which is\n * worked out row by row from the wall clock.\n *\n * The week starts on Monday, as `wow-mongo` truncates it (`$dateTrunc` with\n * `startOfWeek: \"Monday\"`); a quarter starts in January, April, July or\n * October. The zone arithmetic is the platform's (`Intl.DateTimeFormat`):\n * dayjs's timezone plugin answers from the host's own zone rules and was off\n * by an hour on the days the host's clock moves.\n */\nexport function bucketerOf(\n  unit: AggregationDateUnit,\n  zone: string,\n): (at: number) => number {\n  const key = `${unit}|${zone}`;\n  let bucketer = bucketers.get(key);\n  if (!bucketer) {\n    bucketer = newBucketer(unit, zone);\n    bucketers.set(key, bucketer);\n  }\n  return bucketer;\n}\n\nfunction newBucketer(\n  unit: AggregationDateUnit,\n  zone: string,\n): (at: number) => number {\n  if (!Object.values(AggregationDateUnit).includes(unit))\n    throw new Error(`The memory source does not bucket by ${unit}.`);\n  const clock = wallClock(zone);\n  // A UTC day overlaps at most two local days, so each holds a short list.\n  const days = new Map<number, LocalDay[]>();\n  const dayOf = (at: number): LocalDay => {\n    const known = days\n      .get(Math.floor(at / DAY_MS))\n      ?.find(day => day.start <= at && at < day.end);\n    if (known) return known;\n    const day = localDay(at, unit, clock);\n    const last = Math.floor((day.end - 1) / DAY_MS);\n    for (let index = Math.floor(day.start / DAY_MS); index <= last; index++) {\n      const held = days.get(index);\n      if (held) held.push(day);\n      else days.set(index, [day]);\n    }\n    return day;\n  };\n  const width = SUB_DAY_WIDTHS[unit];\n  if (width === undefined) return at => dayOf(at).bucket;\n  return at => {\n    const day = dayOf(at);\n    if (day.regular)\n      return day.start + Math.floor((at - day.start) / width) * width;\n    // The wall clock's own remainder, taken off the instant: the hour keeps\n    // the offset it is read in, as `wow-mongo` truncates it.\n    const wall = clock.wall(at);\n    return at - (mod(wall, DAY_MS) % width);\n  };\n}\n\n/** A zone's wall clock: an instant read as if its wall time were UTC. */\ninterface WallClock {\n  wall(at: number): number;\n  /** The instant a wall time names (`instantAt`). */\n  instant(wall: number): number;\n}\n\nconst clocks = new Map<string, WallClock>();\n\nfunction wallClock(zone: string): WallClock {\n  let clock = clocks.get(zone);\n  if (clock) return clock;\n  const format = new Intl.DateTimeFormat('en-US', {\n    timeZone: zone,\n    hourCycle: 'h23',\n    year: 'numeric',\n    month: 'numeric',\n    day: 'numeric',\n    hour: 'numeric',\n    minute: 'numeric',\n    second: 'numeric',\n    era: 'short',\n  });\n  const wall = (at: number): number => {\n    const parts: Record<string, string> = {};\n    for (const { type, value } of format.formatToParts(at)) parts[type] = value;\n    const year =\n      parts.era === 'BC' ? 1 - Number(parts.year) : Number(parts.year);\n    const date = new Date(0);\n    date.setUTCFullYear(year, Number(parts.month) - 1, Number(parts.day));\n    date.setUTCHours(\n      Number(parts.hour),\n      Number(parts.minute),\n      Number(parts.second),\n      mod(at, 1_000),\n    );\n    return date.getTime();\n  };\n  clock = { wall, instant: local => instantAt(local, wall) };\n  clocks.set(zone, clock);\n  return clock;\n}\n\n/**\n * The instant a wall time names in a zone, as `java.time` resolves one — and\n * so as Wow's dense grid does (`ZonedDateTime`): a wall time the clock passes\n * twice is the earlier instant; one the clock skips is moved later by the\n * gap, so a midnight the zone skips starts its day when the clock resumes.\n */\nfunction instantAt(local: number, wall: (at: number) => number): number {\n  const before = wall(local - DAY_MS) - (local - DAY_MS);\n  const after = wall(local + DAY_MS) - (local + DAY_MS);\n  const named = [local - before, local - after]\n    .filter(at => wall(at) === local)\n    .sort((left, right) => left - right);\n  return named[0] ?? local - before;\n}\n\nfunction localDay(\n  at: number,\n  unit: AggregationDateUnit,\n  clock: WallClock,\n): LocalDay {\n  // The wall date, as a UTC midnight: calendar arithmetic on it is plain.\n  const date = clock.wall(at) - mod(clock.wall(at), DAY_MS);\n  const start = clock.instant(date);\n  const end = clock.instant(date + DAY_MS);\n  const regular =\n    end - start === DAY_MS &&\n    clock.wall(start) - start === clock.wall(end - 1) - (end - 1);\n  return { start, end, regular, bucket: dayBucket(date, start, unit, clock) };\n}\n\n/**\n * The bucket of the local day on wall date `date` (a UTC midnight), which\n * starts at the instant `start`, for a unit of a day or more.\n */\nfunction dayBucket(\n  date: number,\n  start: number,\n  unit: AggregationDateUnit,\n  clock: WallClock,\n): number {\n  const day = new Date(date);\n  const year = day.getUTCFullYear();\n  const month = day.getUTCMonth();\n  const first = (monthIndex: number) => {\n    const midnight = new Date(0);\n    midnight.setUTCFullYear(year, monthIndex, 1);\n    return clock.instant(midnight.getTime());\n  };\n  switch (unit) {\n    case AggregationDateUnit.WEEK:\n      // Days back to Monday: Sunday is day 0 to `Date` and 6 here.\n      return clock.instant(date - ((day.getUTCDay() + 6) % 7) * DAY_MS);\n    case AggregationDateUnit.MONTH:\n      return first(month);\n    case AggregationDateUnit.QUARTER:\n      return first(month - (month % 3));\n    case AggregationDateUnit.YEAR:\n      return first(0);\n    default:\n      return start;\n  }\n}\n\n/**\n * The zone a date histogram buckets in, or a date part reads in: its own, or\n * UTC, as Wow's `AggregationGroup` defaults it — not the reader's.\n */\nexport function zoneOf(\n  group: DateHistogramAggregationGroup | DatePartAggregationGroup,\n): string {\n  return group.timeZone ?? 'UTC';\n}\n\n/** The keys a date part runs through, first and last (Wow's `DatePartFill`). */\nexport const PART_DOMAINS: Record<\n  AggregationDatePart,\n  [first: number, last: number]\n> = {\n  [AggregationDatePart.DAY_OF_WEEK]: [1, 7],\n  [AggregationDatePart.HOUR_OF_DAY]: [0, 23],\n  [AggregationDatePart.DAY_OF_MONTH]: [1, 31],\n  [AggregationDatePart.MONTH_OF_YEAR]: [1, 12],\n};\n\n/** How a date part reads an instant, on the zone's wall clock. */\nexport function parterOf(\n  part: AggregationDatePart,\n  zone: string,\n): (at: number) => number {\n  if (!Object.values(AggregationDatePart).includes(part))\n    throw new Error(`The memory source does not read the date part ${part}.`);\n  const clock = wallClock(zone);\n  return at => {\n    const wall = new Date(clock.wall(at));\n    switch (part) {\n      case AggregationDatePart.DAY_OF_WEEK:\n        return wall.getUTCDay() === 0 ? 7 : wall.getUTCDay();\n      case AggregationDatePart.HOUR_OF_DAY:\n        return wall.getUTCHours();\n      case AggregationDatePart.DAY_OF_MONTH:\n        return wall.getUTCDate();\n      case AggregationDatePart.MONTH_OF_YEAR:\n        return wall.getUTCMonth() + 1;\n    }\n  };\n}\n\n/** More buckets than any answer can show (Wow's limit is 10,000). */\nconst MAX_DENSE_BUCKETS = 100_000;\n\n/**\n * How far to look past a bucket's start for the next one, and how far to\n * step while the look still lands in the same bucket. The first look is\n * shorter than the unit can be; each step is shorter than any bucket, so no\n * bucket is stepped over.\n */\nconst NEXT_BUCKET: Record<AggregationDateUnit, [first: number, step: number]> =\n  {\n    [AggregationDateUnit.SECOND]: [1_000, 1_000],\n    [AggregationDateUnit.MINUTE]: [60_000, 60_000],\n    [AggregationDateUnit.HOUR]: [15 * 60_000, 15 * 60_000],\n    [AggregationDateUnit.DAY]: [22 * HOUR_MS, HOUR_MS],\n    [AggregationDateUnit.WEEK]: [166 * HOUR_MS, HOUR_MS],\n    [AggregationDateUnit.MONTH]: [27 * DAY_MS, HOUR_MS],\n    [AggregationDateUnit.QUARTER]: [88 * DAY_MS, HOUR_MS],\n    [AggregationDateUnit.YEAR]: [364 * DAY_MS, HOUR_MS],\n  };\n\n/**\n * The keys of a dense date histogram, in order, as Wow answers `dense`: every\n * bucket of the unit between the first and the last key that has records —\n * not beyond them. A local date the zone skipped is no bucket; the next\n * bucket start after a start is the one the next instant falls in, so a\n * skipped day is stepped over rather than invented.\n */\nexport function denseKeys(\n  keys: readonly number[],\n  group: DateHistogramAggregationGroup,\n): number[] {\n  if (keys.length === 0) return [];\n  const sorted = [...keys].sort((left, right) => left - right);\n  const last = sorted[sorted.length - 1];\n  const bucketOf = bucketerOf(group.unit, zoneOf(group));\n  const [first, step] = NEXT_BUCKET[group.unit];\n  const answer: number[] = [];\n  for (let key = sorted[0]; ;) {\n    answer.push(key);\n    if (answer.length > MAX_DENSE_BUCKETS)\n      throw new Error(\n        `The memory source fills at most ${MAX_DENSE_BUCKETS} dense buckets.`,\n      );\n    if (key >= last) break;\n    let probe = key + first;\n    while (bucketOf(probe) <= key) probe += step;\n    key = bucketOf(probe);\n  }\n  return answer;\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  AggregationExpressionOperator,\n  AggregationExpressionType,\n  DateDiffUnit,\n  type AggregationExpression,\n} from '@ahoo-wang/wow-client';\nimport { instantOf, numberOf, valueAt } from './values.js';\n\n/** The length of each unit a `DATE_DIFF` measures in; a day is 24 hours. */\nconst DATE_DIFF_MS: Record<DateDiffUnit, number> = {\n  [DateDiffUnit.SECOND]: 1_000,\n  [DateDiffUnit.MINUTE]: 60_000,\n  [DateDiffUnit.HOUR]: 3_600_000,\n  [DateDiffUnit.DAY]: 86_400_000,\n};\n\n/** Wow's four operations; a division by zero has no value. */\nexport function arithmetic(\n  operator: AggregationExpressionOperator,\n  left: number,\n  right: number,\n): number | null {\n  switch (operator) {\n    case AggregationExpressionOperator.ADD:\n      return left + right;\n    case AggregationExpressionOperator.SUBTRACT:\n      return left - right;\n    case AggregationExpressionOperator.MULTIPLY:\n      return left * right;\n    case AggregationExpressionOperator.DIVIDE:\n      return right === 0 ? null : left / right;\n    default:\n      throw new Error(\n        `The memory source does not compute ${String(operator)}.`,\n      );\n  }\n}\n\n/**\n * What one record contributes, before a metric summarises it across the\n * group, or what an `EXPRESSION` filter compares, or what a band is cut from:\n * a field, a number, one operation over two of those, or the time between\n * two moments (`to − from` in the unit). A formula is computed **per record\n * and then summarised** — 金额 − 成本 per order, then summed.\n *\n * `null` is \"no value\", as the service skips such a record: a field that\n * holds no number (an array of one number counts as that number, an array of\n * several as none), a division by zero, a result that is not finite (an\n * overflow), a `DATE_DIFF` missing either moment.\n */\nexport function evaluated(\n  expression: AggregationExpression,\n  record: unknown,\n): number | null {\n  const finite = (value: number | null) =>\n    value !== null && Number.isFinite(value) ? value : null;\n  switch (expression.type) {\n    case AggregationExpressionType.FIELD:\n      return numberOf(valueAt(record, expression.field));\n    case AggregationExpressionType.CONSTANT:\n      return finite(expression.value);\n    case AggregationExpressionType.BINARY: {\n      const left = evaluated(expression.left, record);\n      const right = evaluated(expression.right, record);\n      if (left === null || right === null) return null;\n      return finite(arithmetic(expression.operator, left, right));\n    }\n    case AggregationExpressionType.DATE_DIFF: {\n      const unit = DATE_DIFF_MS[expression.unit];\n      if (unit === undefined)\n        throw new Error(\n          `The memory source does not measure in ${expression.unit}.`,\n        );\n      const from = instantOf(valueAt(record, expression.from));\n      const to = instantOf(valueAt(record, expression.to));\n      return from === null || to === null ? null : (to - from) / unit;\n    }\n    default:\n      throw new Error(\n        `The memory source does not compute the expression ${(expression as { type: string }).type}.`,\n      );\n  }\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Query } from 'mingo';\nimport type { AnyObject } from 'mingo/types';\nimport {\n  ComparisonOperator,\n  DeletionState,\n  FilterOperator,\n  SearchMode,\n  StringComparison,\n  TimeUnit,\n  type ElementFilterExpression,\n  type FilterExpression,\n  type NowFilter,\n} from '@ahoo-wang/wow-client';\nimport type { RecordData } from '../model/record.js';\nimport { evaluated } from './expression.js';\n\ntype Filter = FilterExpression | ElementFilterExpression;\n\n/**\n * Whether one document matches a filter, as `memorySource` reads it — the\n * question a test asks of a condition of its own, such as the one an old\n * screen used, to compare with what a view matched. Unlike a source, it\n * assumes nothing about deletion: without a `DELETION` condition a deleted\n * document is a candidate too. `now` is the clock `BEFORE_NOW` and\n * `AFTER_NOW` compare against (`Date.now` by default).\n */\nexport function matches(\n  document: RecordData,\n  filter: FilterExpression,\n  options: { now?: () => number } = {},\n): boolean {\n  return new Query(criteria(atNow(filter, options.now))).test(document);\n}\n\n/** `value <op> against`, for an `EXPRESSION` filter and a `having`. */\nexport function compares(\n  operator: ComparisonOperator,\n  value: number,\n  against: number,\n): boolean {\n  switch (operator) {\n    case ComparisonOperator.EQ:\n      return value === against;\n    case ComparisonOperator.NE:\n      return value !== against;\n    case ComparisonOperator.GT:\n      return value > against;\n    case ComparisonOperator.GTE:\n      return value >= against;\n    case ComparisonOperator.LT:\n      return value < against;\n    case ComparisonOperator.LTE:\n      return value <= against;\n    default:\n      throw new Error(\n        `The memory source does not compare with ${String(operator)}.`,\n      );\n  }\n}\n\n/**\n * A Wow source answers only the records that are not deleted unless the\n * query carries a `DELETION` filter of its own — that reading is the\n * source's, not the caller's. A document without a `deleted` flag is not\n * deleted (`$ne: true`), where `wow-mongo` asks `deleted == false` of\n * snapshots that always carry the flag.\n */\nexport function withDeletionDefault(filter: FilterExpression): AnyObject {\n  return mentionsDeletion(filter)\n    ? criteria(filter)\n    : { $and: [criteria(filter), { deleted: { $ne: true } }] };\n}\n\nfunction mentionsDeletion(filter: Filter): boolean {\n  switch (filter.op) {\n    case FilterOperator.DELETION:\n      return true;\n    case FilterOperator.AND:\n    case FilterOperator.OR:\n    case FilterOperator.NOR:\n      return filter.operands.some(mentionsDeletion);\n    default:\n      return false;\n  }\n}\n\nconst escape = (text: string) => text.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\n/**\n * Wow's filter as the MongoDB predicate `wow-mongo` compiles it\n * (`AbstractMongoFilterCompiler`), for `mingo` to evaluate: MongoDB's own\n * treatment of a missing field, an explicit null, array elements and case is\n * then the answer — the semantics matrix Wow holds every backend to\n * (`FilterSemantics`, canonical on MongoDB). What has no translation is\n * refused, so a query the source cannot answer fails rather than answering\n * something plausible and wrong.\n *\n * An `ELEMENT_MATCH` predicate names the element's own fields, relative to\n * it, as `$elemMatch` does.\n */\nexport function criteria(filter: Filter): AnyObject {\n  switch (filter.op) {\n    case FilterOperator.MATCH_ALL:\n      return {};\n    case FilterOperator.MATCH_NONE:\n      return { $nor: [{}] };\n    // A computed value compared with a number: a record the expression has\n    // no value for never matches, as wow-mongo's `$expr` guards it.\n    case FilterOperator.EXPRESSION: {\n      const { expression, comparison, value } = filter;\n      return {\n        $where: function (this: unknown) {\n          const computed = evaluated(expression, this);\n          return computed !== null && compares(comparison, computed, value);\n        },\n      };\n    }\n    // The logical and comparison operators carry MongoDB's names in capitals.\n    case FilterOperator.AND:\n    case FilterOperator.OR:\n    case FilterOperator.NOR:\n      return {\n        [`$${filter.op.toLowerCase()}`]: filter.operands.map(criteria),\n      };\n    case FilterOperator.EQ:\n    case FilterOperator.NE:\n    case FilterOperator.GT:\n    case FilterOperator.GTE:\n    case FilterOperator.LT:\n    case FilterOperator.LTE:\n      return {\n        [filter.field]: { [`$${filter.op.toLowerCase()}`]: filter.value },\n      };\n    case FilterOperator.BETWEEN:\n      return {\n        [filter.field]: { $gte: filter.lowerBound, $lte: filter.upperBound },\n      };\n    case FilterOperator.IN:\n      return { [filter.field]: { $in: filter.values } };\n    case FilterOperator.NOT_IN:\n      return { [filter.field]: { $nin: filter.values } };\n    case FilterOperator.CONTAINS_ALL:\n      return { [filter.field]: { $all: filter.values } };\n    // The snapshot's own envelope, which the metadata operators name without\n    // a field.\n    case FilterOperator.AGGREGATE_ID:\n      return { aggregateId: { $eq: filter.value } };\n    case FilterOperator.AGGREGATE_IDS:\n      return { aggregateId: { $in: filter.values } };\n    case FilterOperator.OWNER_ID:\n      return { ownerId: { $eq: filter.value } };\n    // Literal matches through an escaped regular expression.\n    case FilterOperator.CONTAINS:\n    case FilterOperator.STARTS_WITH:\n    case FilterOperator.ENDS_WITH: {\n      const text = escape(filter.value);\n      const pattern =\n        filter.op === FilterOperator.STARTS_WITH\n          ? `^${text}`\n          : filter.op === FilterOperator.ENDS_WITH\n            ? `${text}$`\n            : text;\n      const flags =\n        filter.stringComparison === StringComparison.CASE_INSENSITIVE\n          ? 'i'\n          : '';\n      return { [filter.field]: new RegExp(pattern, flags) };\n    }\n    // `$size: 0`: only an actual empty array — a missing field or a null has\n    // no size.\n    case FilterOperator.IS_EMPTY:\n      return { [filter.field]: { $size: 0 } };\n    // `= null` matches null and a missing field; `!= null` neither.\n    case FilterOperator.IS_NULL:\n      return { [filter.field]: { $eq: null } };\n    case FilterOperator.IS_NOT_NULL:\n      return { [filter.field]: { $ne: null } };\n    // Wow lowers both before a store reads them (`FilterOperatorSpec`):\n    // `= \"\"`, and `!= null AND != \"\"` — a missing or null field is not a\n    // non-empty string.\n    case FilterOperator.IS_EMPTY_STRING:\n      return { [filter.field]: { $eq: '' } };\n    case FilterOperator.IS_NOT_EMPTY_STRING:\n      return {\n        $and: [\n          { [filter.field]: { $ne: null } },\n          { [filter.field]: { $ne: '' } },\n        ],\n      };\n    // Whether the path is there at all: a field holding null exists.\n    case FilterOperator.EXISTS:\n      return { [filter.field]: { $exists: true } };\n    case FilterOperator.NOT_EXISTS:\n      return { [filter.field]: { $exists: false } };\n    case FilterOperator.DELETION:\n      return filter.state === DeletionState.ALL\n        ? {}\n        : { deleted: { $eq: filter.state === DeletionState.DELETED } };\n    // Full text over the fields the search names, without regard to case: a\n    // phrase is the words together, in order; terms are any one of them.\n    // MongoDB's text index decides relevance and stemming; this is the\n    // literal reading of it.\n    case FilterOperator.SEARCH: {\n      if (!filter.fields?.length)\n        throw new Error('The memory source searches named fields only.');\n      const words =\n        filter.mode === SearchMode.PHRASE\n          ? [filter.query.trim()]\n          : filter.query.trim().split(/\\s+/);\n      return {\n        $or: filter.fields.flatMap(field =>\n          words.map(word => ({\n            [String(field)]: new RegExp(escape(word), 'i'),\n          })),\n        ),\n      };\n    }\n    case FilterOperator.ELEMENT_MATCH:\n      return { [filter.field]: { $elemMatch: criteria(filter.predicate) } };\n    default:\n      throw new Error(\n        `The memory source does not evaluate ${(filter as { op: string }).op}.`,\n      );\n  }\n}\n\n/**\n * A query with every `BEFORE_NOW` / `AFTER_NOW` in it — at the root, in a\n * logical or element match, in a metric's or an element's filter — lowered\n * the way Wow's `FilterNormalizer` lowers them: to `LT` / `GT` against\n * `now + offset`, encoded as the field keeps its time. The clock is read\n * once, and only when the query holds one.\n */\nexport function atNow<Q>(query: Q, clock: () => number = Date.now): Q {\n  let now: number | undefined;\n  const lower = (node: unknown): unknown => {\n    if (Array.isArray(node)) return node.map(lower);\n    if (node === null || typeof node !== 'object' || node instanceof RegExp)\n      return node;\n    const op = (node as { op?: unknown }).op;\n    if (op === FilterOperator.BEFORE_NOW || op === FilterOperator.AFTER_NOW) {\n      now ??= clock();\n      return nowComparison(node as NowFilter, now);\n    }\n    return Object.fromEntries(\n      Object.entries(node).map(([key, value]) => [key, lower(value)]),\n    );\n  };\n  return lower(query) as Q;\n}\n\n/** How many of each of Wow's time units one millisecond is. */\nconst PER_MILLISECOND: Record<TimeUnit, number> = {\n  [TimeUnit.NANOSECONDS]: 1_000_000,\n  [TimeUnit.MICROSECONDS]: 1_000,\n  [TimeUnit.MILLISECONDS]: 1,\n  [TimeUnit.SECONDS]: 1 / 1_000,\n  [TimeUnit.MINUTES]: 1 / 60_000,\n  [TimeUnit.HOURS]: 1 / 3_600_000,\n  [TimeUnit.DAYS]: 1 / 86_400_000,\n};\n\n/**\n * `field < now + offset` or `field > now + offset`, strictly, the moment\n * counted in the filter's `timeUnit` and truncated as `TimeUnit.convert`\n * truncates it. A record without the field matches neither.\n */\nfunction nowComparison(filter: NowFilter, now: number): FilterExpression {\n  if (filter.datePattern !== undefined)\n    throw new Error(\n      'The memory source keeps times as epoch numbers, not as formatted text.',\n    );\n  const moment = now + durationMs(filter.offset ?? 'PT0S');\n  const unit = filter.timeUnit ?? TimeUnit.MILLISECONDS;\n  return {\n    op:\n      filter.op === FilterOperator.BEFORE_NOW\n        ? FilterOperator.LT\n        : FilterOperator.GT,\n    field: filter.field,\n    value: Math.trunc(moment * PER_MILLISECOND[unit]),\n  };\n}\n\n/** `java.time.Duration.parse`'s grammar: days, hours, minutes, seconds. */\nconst DURATION =\n  /^([-+]?)P(?:([-+]?\\d+)D)?(?:T(?=[-+]?\\d)(?:([-+]?\\d+)H)?(?:([-+]?\\d+)M)?(?:([-+]?\\d+)(?:[.,](\\d{0,9}))?S)?)?$/i;\n\n/**\n * An ISO-8601 duration as `java.time.Duration.parse` reads it — each part\n * optionally signed, the whole optionally negated — in milliseconds.\n */\nfunction durationMs(text: string): number {\n  const match = DURATION.exec(text);\n  if (!match || match.slice(2, 6).every(part => part === undefined))\n    throw new Error(`The memory source does not read the duration ${text}.`);\n  const [, sign, days, hours, minutes, seconds, fraction] = match;\n  const fractionMs =\n    Number(`0.${fraction ?? '0'}`) *\n    1_000 *\n    (seconds?.startsWith('-') ? -1 : 1);\n  const ms =\n    Number(days ?? 0) * 86_400_000 +\n    Number(hours ?? 0) * 3_600_000 +\n    Number(minutes ?? 0) * 60_000 +\n    Number(seconds ?? 0) * 1_000 +\n    fractionMs;\n  return sign === '-' ? -ms : ms;\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Query, find } from 'mingo';\nimport {\n  AGGREGATION_LIMITS,\n  AggregationExpressionType,\n  AggregationFunction,\n  AggregationGroupType,\n  AggregationMetricType,\n  DerivedExpressionType,\n  HavingExpressionType,\n  SortDirection,\n  type AggregationGroup,\n  type AggregationMetric,\n  type AggregationQuery,\n  type DateHistogramAggregationGroup,\n  type DatePartAggregationGroup,\n  type DerivedExpression,\n  type FieldSort,\n  type HavingExpression,\n} from '@ahoo-wang/wow-client';\nimport {\n  PART_DOMAINS,\n  bucketerOf,\n  denseKeys,\n  parterOf,\n  zoneOf,\n} from './calendar.js';\nimport { arithmetic, evaluated } from './expression.js';\nimport { compares, criteria } from './filter.js';\nimport { compareValues, instantOf, numberOf, valueAt } from './values.js';\nimport type { RecordData } from '../model/record.js';\n\n/**\n * One aggregation over the records a query's root filter has already\n * matched, with Wow's answer shape and order:\n *\n * 1. `elements` replace the records by the elements of an array, step by\n *    step — each path relative to the step before, each gate filter naming\n *    the element's own fields; what is left is counted as if each element\n *    were a record.\n * 2. The groups key each record; a metric's own `filter` decides, per\n *    record, whether that record counts toward that one metric.\n * 3. A `dense` date group fills its empty buckets; the derived metrics are\n *    computed over each grouped row; `having` keeps the rows it admits.\n * 4. The rows are sorted by the query's sort, then by every group alias it\n *    does not name, ascending, as Wow appends them; and cut to `limit`\n *    (Wow's default 100) — after the having, so the top five of what is\n *    kept.\n *\n * An ungrouped aggregation always answers its one row, over nothing too: a\n * count of 0 and null for a value nothing contributed to.\n */\nexport function summarise(\n  matched: readonly RecordData[],\n  query: AggregationQuery,\n): RecordData[] {\n  const units = expand(matched, query);\n  const groupBy = query.groupBy ?? [];\n  const dense = denseGroup(groupBy);\n  const metrics = query.metrics.filter(\n    metric => metric.type !== AggregationMetricType.DERIVED,\n  );\n  const gates = metrics.map(metric => {\n    const filter = 'filter' in metric ? metric.filter : undefined;\n    return filter ? new Query(criteria(filter)) : undefined;\n  });\n  const keyers = groupBy.map(keyerOf);\n  const groups = new Map<string, { keys: unknown[]; units: RecordData[] }>();\n  if (groupBy.length === 0) groups.set('[]', { keys: [], units: [] });\n  const denseAt = dense ? groupBy.indexOf(dense) : -1;\n  for (const unit of units) {\n    const keys = keyers.map(keyOf => keyOf(unit));\n    // Wow puts no record without a time into a dense histogram.\n    if (denseAt >= 0 && keys[denseAt] === null) continue;\n    const id = JSON.stringify(keys);\n    let group = groups.get(id);\n    if (!group) groups.set(id, (group = { keys, units: [] }));\n    group.units.push(unit);\n  }\n  let rows = [...groups.values()].map(({ keys, units: members }) =>\n    rowOf(groupBy, keys, metrics, gates, members),\n  );\n  if (dense) rows = filled(rows, dense, metrics);\n  rows = rows.map(row => withDerived(row, query.metrics));\n  if (query.having) rows = rows.filter(row => keeps(query.having!, row));\n  rows = sorted(rows, query.sort ?? [], groupBy);\n  return rows.slice(0, query.limit ?? AGGREGATION_LIMITS.DEFAULT_LIMIT);\n}\n\n/** The innermost elements the aggregation counts: the records, when it names none. */\nfunction expand(\n  matched: readonly RecordData[],\n  query: AggregationQuery,\n): RecordData[] {\n  let scope = [...matched];\n  for (const element of query.elements ?? []) {\n    scope = scope.flatMap(record => {\n      const items = valueAt(record, element.path);\n      return Array.isArray(items)\n        ? items.filter(\n            (item): item is RecordData =>\n              item !== null && typeof item === 'object' && !Array.isArray(item),\n          )\n        : [];\n    });\n    if (element.filter) scope = find(scope, criteria(element.filter)).all();\n  }\n  return scope;\n}\n\n/**\n * The one dense date group of a query, or none. Wow fills empty buckets only\n * when the date group is the query's only group (`AggregationQuery` refuses\n * `dense` beside another), so that shape is refused here too.\n */\nfunction denseGroup(\n  groupBy: readonly AggregationGroup[],\n): DateHistogramAggregationGroup | DatePartAggregationGroup | undefined {\n  const dense = groupBy.find(\n    (\n      group,\n    ): group is DateHistogramAggregationGroup | DatePartAggregationGroup =>\n      (group.type === AggregationGroupType.DATE_HISTOGRAM ||\n        group.type === AggregationGroupType.DATE_PART) &&\n      group.dense === true,\n  );\n  if (dense && groupBy.length > 1)\n    throw new Error(\n      `The memory source fills a dense ${dense.type} only when it is the only group.`,\n    );\n  return dense;\n}\n\n/**\n * How one group keys a record, as the service answers the key:\n *\n * - `TERMS`: the value — `null` where the field is missing or null, or the\n *   group's `missingKey` there (`$ifNull`); an expression's number.\n * - `HISTOGRAM`: the lower bound of the band of `interval` the number falls\n *   in, counted from zero.\n * - `DATE_HISTOGRAM`: the start of the unit in the group's zone, in epoch\n *   milliseconds (`bucketerOf`): a week starts on Monday, a quarter in\n *   January, April, July or October.\n * - `DATE_PART`: the part's integer on the zone's wall clock — the ISO\n *   weekday 1 (Monday) to 7, the hour 0 to 23, the day, the month 1 to 12.\n */\nfunction keyerOf(group: AggregationGroup): (unit: RecordData) => unknown {\n  switch (group.type) {\n    case AggregationGroupType.TERMS: {\n      const { field, expression, missingKey } = group;\n      return unit => {\n        const value =\n          field === undefined\n            ? evaluated(expression, unit)\n            : valueAt(unit, field);\n        return value ?? missingKey ?? null;\n      };\n    }\n    case AggregationGroupType.HISTOGRAM: {\n      const { field, expression, interval } = group;\n      return unit => {\n        const value =\n          field === undefined\n            ? evaluated(expression, unit)\n            : valueAt(unit, field);\n        return typeof value === 'number' && Number.isFinite(value)\n          ? Math.floor(value / interval) * interval\n          : null;\n      };\n    }\n    case AggregationGroupType.DATE_HISTOGRAM: {\n      const bucketOf = bucketerOf(group.unit, zoneOf(group));\n      return unit => {\n        const at = instantOf(valueAt(unit, group.field));\n        return at === null ? null : bucketOf(at);\n      };\n    }\n    case AggregationGroupType.DATE_PART: {\n      const partOf = parterOf(group.part, zoneOf(group));\n      return unit => {\n        const at = instantOf(valueAt(unit, group.field));\n        return at === null ? null : partOf(at);\n      };\n    }\n    default:\n      throw new Error(\n        `The memory source does not group by ${(group as { type: string }).type}.`,\n      );\n  }\n}\n\n/** One grouped row: the group keys, then each metric over its members. */\nfunction rowOf(\n  groupBy: readonly AggregationGroup[],\n  keys: readonly unknown[],\n  metrics: readonly AggregationMetric[],\n  gates: readonly (Query | undefined)[],\n  members: readonly RecordData[],\n): RecordData {\n  const row: RecordData = {};\n  groupBy.forEach((group, index) => (row[group.alias] = keys[index]));\n  metrics.forEach((metric, index) => {\n    const gate = gates[index];\n    row[metric.alias] = metricOf(\n      metric,\n      gate ? members.filter(unit => gate.test(unit)) : members,\n    );\n  });\n  return row;\n}\n\n/**\n * One metric over the records that count toward it. Only finite numbers\n * contribute to a numeric one (`evaluated`); a metric nothing contributed to\n * answers null, a count 0.\n *\n * - `STDDEV` and `VARIANCE` are the population's, as `$stdDevPop`.\n * - `PERCENTILE` is exact: sorted values, the rank `(n − 1) · p / 100`, and\n *   linear interpolation between the two values either side of it. The\n *   service's is an estimate that lands between those same two values (the\n *   bounds its TCK holds each backend to).\n * - `DISTINCT_COUNT` counts the distinct values, null aside; an array field\n *   contributes each of its elements.\n * - `ANY` answers the greatest value, null aside, as `wow-mongo`'s `$max`.\n * - `FIRST` / `LAST` answer the value on the earliest / latest record by\n *   `orderBy` (the model's `eventTime` when it names none); only a record\n *   with both a value and a time counts, and the first of a tie is kept.\n */\nfunction metricOf(\n  metric: AggregationMetric,\n  members: readonly RecordData[],\n): unknown {\n  switch (metric.type) {\n    case AggregationMetricType.COUNT:\n      return members.length;\n    case AggregationMetricType.NUMERIC:\n    case AggregationMetricType.PERCENTILE: {\n      if (\n        metric.type === AggregationMetricType.NUMERIC &&\n        (metric.function === AggregationFunction.MIN ||\n          metric.function === AggregationFunction.MAX) &&\n        metric.expression.type === AggregationExpressionType.FIELD\n      )\n        return extremeOf(\n          members,\n          metric.expression.field,\n          metric.function === AggregationFunction.MAX,\n        );\n      const values = members\n        .map(unit => evaluated(metric.expression, unit))\n        .filter((value): value is number => value !== null);\n      if (values.length === 0) return null;\n      if (metric.type === AggregationMetricType.PERCENTILE)\n        return percentileOf(values, metric.percentile);\n      return numericOf(values, metric.function);\n    }\n    case AggregationMetricType.DISTINCT_COUNT: {\n      const { expression } = metric;\n      const seen = new Set<string>();\n      for (const unit of members) {\n        const value =\n          expression.type === AggregationExpressionType.FIELD\n            ? valueAt(unit, expression.field)\n            : evaluated(expression, unit);\n        for (const each of Array.isArray(value) ? value : [value])\n          if (each !== null && each !== undefined)\n            seen.add(JSON.stringify(each));\n      }\n      return seen.size;\n    }\n    case AggregationMetricType.ANY: {\n      let best: unknown = null;\n      for (const unit of members) {\n        const value = valueAt(unit, metric.field);\n        if (value === null || value === undefined) continue;\n        if (best === null || compareValues(value, best) > 0) best = value;\n      }\n      return best;\n    }\n    case AggregationMetricType.FIRST:\n    case AggregationMetricType.LAST: {\n      const first = metric.type === AggregationMetricType.FIRST;\n      let best: { at: number; value: unknown } | undefined;\n      for (const unit of members) {\n        const at = instantOf(valueAt(unit, metric.orderBy ?? 'eventTime'));\n        const value = valueAt(unit, metric.field);\n        if (at === null || value === null || value === undefined) continue;\n        if (!best || (first ? at < best.at : at > best.at))\n          best = { at, value };\n      }\n      return best ? best.value : null;\n    }\n    default:\n      throw new Error(\n        `The memory source does not compute ${(metric as { alias: string }).alias}.`,\n      );\n  }\n}\n\n/**\n * `MIN` / `MAX` of a field, as `$min` / `$max` read it: any value compares,\n * in MongoDB's order, so the latest of a time kept as ISO text is that time\n * rather than no number. Null and a missing field are skipped; an array\n * counts as its one number, or not at all.\n */\nfunction extremeOf(\n  members: readonly RecordData[],\n  field: string,\n  greatest: boolean,\n): unknown {\n  let best: unknown = null;\n  for (const unit of members) {\n    const raw = valueAt(unit, field);\n    const value = typeof raw === 'string' ? raw : numberOf(raw);\n    if (value === null) continue;\n    const by = best === null ? 1 : compareValues(value, best);\n    if (greatest ? by > 0 : by < 0 || best === null) best = value;\n  }\n  return best;\n}\n\nfunction numericOf(values: number[], fn: AggregationFunction): number | null {\n  const sum = values.reduce((total, value) => total + value, 0);\n  const mean = sum / values.length;\n  let answer: number;\n  switch (fn) {\n    case AggregationFunction.SUM:\n      answer = sum;\n      break;\n    case AggregationFunction.AVG:\n      answer = mean;\n      break;\n    case AggregationFunction.MIN:\n      answer = Math.min(...values);\n      break;\n    case AggregationFunction.MAX:\n      answer = Math.max(...values);\n      break;\n    case AggregationFunction.STDDEV:\n    case AggregationFunction.VARIANCE: {\n      const variance =\n        values.reduce((total, value) => total + (value - mean) ** 2, 0) /\n        values.length;\n      answer =\n        fn === AggregationFunction.VARIANCE ? variance : Math.sqrt(variance);\n      break;\n    }\n    default:\n      throw new Error(`The memory source does not compute ${String(fn)}.`);\n  }\n  return Number.isFinite(answer) ? answer : null;\n}\n\nfunction percentileOf(values: number[], percentile: number): number {\n  const sorted = [...values].sort((left, right) => left - right);\n  const rank = ((sorted.length - 1) * percentile) / 100;\n  const below = Math.floor(rank);\n  const above = Math.min(below + 1, sorted.length - 1);\n  return sorted[below] + (rank - below) * (sorted[above] - sorted[below]);\n}\n\n/**\n * What each metric answers over no record at all: a count of 0, and null\n * for everything that has no value without one.\n */\nfunction emptyValues(metrics: readonly AggregationMetric[]): RecordData {\n  return Object.fromEntries(\n    metrics.map(metric => [metric.alias, metricOf(metric, [])]),\n  );\n}\n\n/**\n * The grouped rows of a dense group with its empty keys filled in, in key\n * order, as Wow answers `dense`: a date part runs through its whole domain,\n * a date histogram through every bucket between its first and last (see\n * `denseKeys`); a filled key answers what its metrics answer over nothing.\n */\nfunction filled(\n  rows: readonly RecordData[],\n  group: DateHistogramAggregationGroup | DatePartAggregationGroup,\n  metrics: readonly AggregationMetric[],\n): RecordData[] {\n  const byKey = new Map<unknown, RecordData>(\n    rows.map(row => [row[group.alias], row]),\n  );\n  let keys: number[];\n  if (group.type === AggregationGroupType.DATE_PART) {\n    const [first, last] = PART_DOMAINS[group.part];\n    keys = Array.from(\n      { length: last - first + 1 },\n      (_, index) => first + index,\n    );\n  } else keys = denseKeys([...byKey.keys()] as number[], group);\n  return keys.map(\n    key => byKey.get(key) ?? { [group.alias]: key, ...emptyValues(metrics) },\n  );\n}\n\n/**\n * The derived metrics of one grouped row, in declaration order, so a derived\n * metric may read one declared before it. A number that cannot be computed —\n * a missing operand, a division by zero — is `null`.\n */\nfunction withDerived(\n  row: RecordData,\n  metrics: readonly AggregationMetric[],\n): RecordData {\n  const answer: RecordData = { ...row };\n  for (const metric of metrics)\n    if (metric.type === AggregationMetricType.DERIVED)\n      answer[metric.alias] = derive(metric.expression, answer);\n  return answer;\n}\n\nfunction derive(expression: DerivedExpression, row: RecordData): number | null {\n  switch (expression.type) {\n    case DerivedExpressionType.CONSTANT:\n      return expression.value;\n    case DerivedExpressionType.METRIC_REF: {\n      const value = row[expression.metric];\n      return typeof value === 'number' && Number.isFinite(value) ? value : null;\n    }\n    case DerivedExpressionType.BINARY: {\n      const left = derive(expression.left, row);\n      const right = derive(expression.right, row);\n      if (left === null || right === null) return null;\n      const value = arithmetic(expression.operator, left, right);\n      return value !== null && Number.isFinite(value) ? value : null;\n    }\n    default:\n      throw new Error(\n        `The memory source does not derive ${(expression as { type: string }).type}.`,\n      );\n  }\n}\n\n/**\n * Whether one grouped row survives the having. A metric with no number\n * passes no comparison, range or set — there is nothing to compare — and\n * only `IS_NULL` asks about that.\n */\nfunction keeps(having: HavingExpression, row: RecordData): boolean {\n  const numberAt = (metric: string) => {\n    const value = row[metric];\n    return typeof value === 'number' && Number.isFinite(value) ? value : null;\n  };\n  switch (having.type) {\n    case HavingExpressionType.AND:\n      return having.operands.every(operand => keeps(operand, row));\n    case HavingExpressionType.OR:\n      return having.operands.some(operand => keeps(operand, row));\n    case HavingExpressionType.CONDITION: {\n      const value = numberAt(having.metric);\n      return value !== null && compares(having.operator, value, having.value);\n    }\n    case HavingExpressionType.BETWEEN: {\n      const value = numberAt(having.metric);\n      return value !== null && value >= having.lower && value <= having.upper;\n    }\n    case HavingExpressionType.IN: {\n      const value = numberAt(having.metric);\n      return value !== null && having.values.includes(value);\n    }\n    case HavingExpressionType.IS_NULL:\n      return (numberAt(having.metric) === null) !== (having.negated === true);\n    default:\n      throw new Error(\n        `The memory source does not evaluate ${(having as { type: string }).type}.`,\n      );\n  }\n}\n\n/**\n * The rows in the query's order, then by each group alias the sort does not\n * name, ascending — Wow appends them so ties come out the same every time.\n * Values compare in MongoDB's order: null before any number, so a null sorts\n * first ascending and last descending.\n */\nfunction sorted(\n  rows: readonly RecordData[],\n  sort: readonly FieldSort[],\n  groupBy: readonly AggregationGroup[],\n): RecordData[] {\n  const named = new Set(sort.map(({ field }) => field));\n  const order = [\n    ...sort.map(({ field, direction }) => ({\n      field,\n      sign: direction === SortDirection.DESC ? -1 : 1,\n    })),\n    ...groupBy\n      .filter(({ alias }) => !named.has(alias))\n      .map(({ alias }) => ({ field: alias, sign: 1 })),\n  ];\n  if (order.length === 0) return [...rows];\n  return [...rows].sort((left, right) => {\n    for (const { field, sign } of order) {\n      const by = compareValues(left[field], right[field]);\n      if (by !== 0) return by * sign;\n    }\n    return 0;\n  });\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { find } from 'mingo';\nimport {\n  DEFAULT_PAGINATION,\n  FilterOperator,\n  SortDirection,\n  type AggregationQuery,\n  type FieldSort,\n  type FilterExpression,\n} from '@ahoo-wang/wow-client';\nimport type { RecordData } from '../model/record.js';\nimport type { ViewSource } from '../runtime/source.js';\nimport { summarise } from './aggregate.js';\nimport { atNow, withDeletionDefault } from './filter.js';\nimport { valueAt } from './values.js';\n\n/**\n * How `memorySource` keeps and reads its documents. None of it changes an\n * answer.\n */\nexport interface MemorySourceOptions {\n  /**\n   * The service's clock, in epoch milliseconds, which `BEFORE_NOW` and\n   * `AFTER_NOW` compare against, read once per query and only by a query that\n   * holds one of them. Defaults to `Date.now`. A test pins it to the moment\n   * its data is built around — the one it pins the page's clock to — so\n   * 「晚于现在」 answers the same on every run.\n   */\n  now?: () => number;\n  /**\n   * A time column every document holds as epoch milliseconds, the way a Wow\n   * snapshot keeps `firstEventTime`. The documents are kept in its order — a\n   * query with no sort of its own reads them oldest first — and a range on it\n   * in the filter's top-level AND is cut out by binary search before the\n   * filter reads anything. For large sets; without it the documents keep the\n   * order they came in.\n   */\n  timeField?: string;\n  /**\n   * Answer a repeated aggregation from memory, keyed by the query, each\n   * caller getting its own copy. Only for documents that never change under\n   * the source; off by default, so a test that edits a document (a command\n   * it stubs) sees the edit in the next answer.\n   */\n  remember?: boolean;\n}\n\n/** How many distinct aggregations one source remembers before it starts over. */\nconst MEMO_LIMIT = 512;\n\n/**\n * A `ViewSource` over documents held in memory that answers each query the\n * way a Wow service over MongoDB does — filter, sort, page, projection and\n * aggregation — so a host's test sees the engine's real queries answered by\n * the semantics the engine is built on, not a canned answer.\n *\n * The documents are the snapshots (or event streams) as the service returns\n * them: `aggregateId`, `ownerId` and `deleted` on the envelope, the state\n * under `state`, times as epoch milliseconds. A document with\n * `deleted: true` is left out unless the filter carries a `DELETION`\n * condition. A cursor is an offset, as opaque to the caller as Wow's.\n *\n * What it cannot answer — an operator or shape it has no reading of, such as\n * `ID`, `TENANT_ID`, `SPACE_ID` or the calendar filters (`TODAY`, …) the\n * engine never sends — is refused with an error, so a query a test starts to\n * send fails rather than getting a plausible wrong answer. The documents are\n * read, never written; a test may change them between queries.\n */\nexport function memorySource(\n  documents: readonly RecordData[],\n  options: MemorySourceOptions = {},\n): ViewSource {\n  const table = tableOf(documents, options.timeField);\n  const answers = new Map<string, RecordData[]>();\n  const clock = options.now;\n  return {\n    paged: asked =>\n      settled(() => {\n        const query = atNow(asked, clock);\n        const matched = matchedIn(table, query.filter, query.sort);\n        const { index, size } = query.pagination ?? DEFAULT_PAGINATION;\n        const start = (index - 1) * size;\n        return {\n          total: matched.length,\n          list: matched.slice(start, start + size).map(projected(query)),\n        };\n      }),\n    cursor: asked =>\n      settled(() => {\n        const query = atNow(asked, clock);\n        const matched = matchedIn(table, query.filter, query.sort);\n        const start = Number(query.cursor ?? 0);\n        const end = start + (query.size ?? matched.length);\n        return {\n          list: matched.slice(start, end).map(projected(query)),\n          nextCursor: end < matched.length ? String(end) : null,\n        };\n      }),\n    aggregate: asked =>\n      settled(() => {\n        // Keyed by the moment asked about, not by the words 「晚于现在」.\n        const query = atNow(asked, clock);\n        if (!options.remember) return aggregateOver(table, query);\n        const key = JSON.stringify(query);\n        let answer = answers.get(key);\n        if (!answer) {\n          answer = aggregateOver(table, query);\n          if (answers.size >= MEMO_LIMIT) answers.clear();\n          answers.set(key, answer);\n        }\n        return structuredClone(answer);\n      }),\n  };\n}\n\n/** `work`'s answer as a service's: a promise, what it throws a rejection. */\nfunction settled<T>(work: () => T): Promise<T> {\n  return new Promise(resolve => resolve(work()));\n}\n\nfunction aggregateOver(table: Table, query: AggregationQuery): RecordData[] {\n  const filter = query.filter ?? { op: FilterOperator.MATCH_ALL };\n  return summarise(matchedIn(table, filter), query);\n}\n\n/** The documents a source answers from, with the time column's values beside them. */\ninterface Table {\n  documents: RecordData[];\n  timeField?: string;\n  times?: Float64Array;\n}\n\nfunction tableOf(documents: readonly RecordData[], timeField?: string): Table {\n  if (timeField === undefined) return { documents: [...documents] };\n  const timed = documents.map(document => {\n    const at = valueAt(document, timeField);\n    if (typeof at !== 'number' || !Number.isFinite(at))\n      throw new Error(\n        `The memory source keeps ${timeField} as epoch milliseconds; a document holds ${String(at)}.`,\n      );\n    return { document, at };\n  });\n  // A stable sort: documents of the same instant keep the order they came in.\n  timed.sort((left, right) => left.at - right.at);\n  return {\n    documents: timed.map(({ document }) => document),\n    timeField,\n    times: Float64Array.from(timed, ({ at }) => at),\n  };\n}\n\nfunction matchedIn(\n  table: Table,\n  filter: FilterExpression,\n  sort: readonly FieldSort[] = [],\n): RecordData[] {\n  const cursor = find(scoped(table, filter), withDeletionDefault(filter));\n  return (sort.length > 0 ? cursor.sort(sortSpec(sort)) : cursor).all();\n}\n\nfunction sortSpec(sort: readonly FieldSort[]): Record<string, 1 | -1> {\n  return Object.fromEntries(\n    sort.map(({ field, direction }) => [\n      field,\n      direction === SortDirection.DESC ? -1 : 1,\n    ]),\n  );\n}\n\n/**\n * A document as the service answers it: only the paths the query's\n * projection includes, when it has one — MongoDB's own projection, where a\n * path through an array picks that member of every element.\n */\nfunction projected(query: { projection?: { include?: readonly string[] } }) {\n  const include = query.projection?.include;\n  if (!include || include.length === 0)\n    return (document: RecordData) => document;\n  const spec = Object.fromEntries(include.map(path => [path, 1]));\n  return (document: RecordData): RecordData =>\n    find([document], {}, spec).all()[0] ?? {};\n}\n\n/**\n * The documents a filter can match, before it reads them: all of them, or —\n * when the filter's top-level AND bounds the time column with numbers — the\n * slice between those bounds, found by binary search. The whole filter still\n * runs over the slice, so the slice only ever holds more than the answer.\n */\nfunction scoped(table: Table, filter: FilterExpression): RecordData[] {\n  const { documents, timeField, times } = table;\n  if (timeField === undefined || !times) return documents;\n  let from = 0;\n  let to = documents.length;\n  for (const condition of conjuncts(filter)) {\n    if (!('field' in condition) || condition.field !== timeField) continue;\n    switch (condition.op) {\n      case FilterOperator.GT:\n      case FilterOperator.GTE:\n      case FilterOperator.LT:\n      case FilterOperator.LTE:\n      case FilterOperator.EQ: {\n        const { op, value } = condition;\n        if (typeof value !== 'number' || !Number.isFinite(value)) break;\n        if (op !== FilterOperator.LT && op !== FilterOperator.LTE)\n          from = Math.max(\n            from,\n            firstAt(times, value, op === FilterOperator.GT),\n          );\n        if (op !== FilterOperator.GT && op !== FilterOperator.GTE)\n          to = Math.min(to, firstAt(times, value, op !== FilterOperator.LT));\n        break;\n      }\n      case FilterOperator.BETWEEN: {\n        const { lowerBound, upperBound } = condition;\n        if (typeof lowerBound === 'number' && Number.isFinite(lowerBound))\n          from = Math.max(from, firstAt(times, lowerBound, false));\n        if (typeof upperBound === 'number' && Number.isFinite(upperBound))\n          to = Math.min(to, firstAt(times, upperBound, true));\n        break;\n      }\n      default:\n        break;\n    }\n  }\n  if (from === 0 && to === documents.length) return documents;\n  return from < to ? documents.slice(from, to) : [];\n}\n\n/** The conditions every match must meet: an AND's operands, nested ANDs flattened. */\nfunction conjuncts(filter: FilterExpression): FilterExpression[] {\n  return filter.op === FilterOperator.AND\n    ? filter.operands.flatMap(conjuncts)\n    : [filter];\n}\n\n/**\n * The index of the first time at or past `value` — strictly past it when\n * `after` — in ascending `times`; `times.length` when there is none.\n */\nfunction firstAt(times: Float64Array, value: number, after: boolean): number {\n  let low = 0;\n  let high = times.length;\n  while (low < high) {\n    const middle = (low + high) >>> 1;\n    if (after ? times[middle] <= value : times[middle] < value)\n      low = middle + 1;\n    else high = middle;\n  }\n  return low;\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Everything a host declares, admitted as the engine would admit it, in a\n * test (`/testing`'s `admit`, host-integration.md 6): no store, no source,\n * no clock — the descriptors are the snapshots the host commits.\n */\n\nimport type { QueryModelDescriptor } from '@ahoo-wang/wow-client';\nimport {\n  DEFAULT_RUNTIME_LIMITS,\n  type Issue,\n  type RuntimeLimits,\n  type ViewDefinition,\n} from '../model/index.js';\nimport {\n  builtinFieldKinds,\n  issue,\n  type FieldKindRegistry,\n} from '../filter/index.js';\nimport { narrowDefinition } from '../capabilities/index.js';\nimport { sayDefinition } from './definitions.js';\nimport { validateDefinition } from './validateDefinition.js';\n\n/**\n * What `admit` takes one of: a definition, or a resource holding one — the\n * shape a host registers (host-integration.md 4), so a host's list of\n * resources is passed as it is.\n */\nexport type Admissible = ViewDefinition | { definition: ViewDefinition };\n\nexport interface AdmitOptions {\n  /** The words the definitions' keys are said in (`ViewEngineOptions.text`). */\n  text?(key: string): string | undefined;\n  kinds?: FieldKindRegistry;\n  limits?: Partial<RuntimeLimits>;\n}\n\n/** One finding, with the definition it is about. */\nexport type AdmitFinding = Issue & { definition: string };\n\n/**\n * Every finding the engine would have about `definitions` over\n * `descriptors` (the snapshots, by `DataViewDefinition.source`), each with\n * the definition it is about; `[]` for a host's declarations that hold.\n *\n * Each definition is admitted as the engine admits it when registered —\n * its keys said in `text`, its own rules, its boards against every other\n * definition (C) — and each data definition narrowed to its descriptor as\n * a source would narrow it (N5), what that takes away said too. A\n * definition over a source with no descriptor given is said to be, since\n * its capabilities go unchecked.\n */\nexport function admit(\n  definitions: readonly Admissible[],\n  descriptors: Readonly<Record<string, QueryModelDescriptor>>,\n  options: AdmitOptions = {},\n): AdmitFinding[] {\n  const kinds = options.kinds ?? builtinFieldKinds;\n  const limits = { ...DEFAULT_RUNTIME_LIMITS, ...options.limits };\n  // Called on the host's object, as the engine's registry calls it.\n  const text = (key: string) => options.text?.(key);\n  const said = definitions.map(entry =>\n    sayDefinition('definition' in entry ? entry.definition : entry, text),\n  );\n  const findings = new Map<string, Issue[]>();\n  const declared = new Map(\n    said.map(({ definition }) => [definition.id, definition]),\n  );\n  for (const { definition, findings: text } of said) {\n    findings.set(definition.id, [...text]);\n    if (definition.kind !== 'data') continue;\n    const descriptor = descriptors[definition.source];\n    if (!descriptor) {\n      findings\n        .get(definition.id)\n        ?.push(\n          issue(\n            'definition.descriptor.missing',\n            ['source'],\n            { source: definition.source },\n            'warning',\n          ),\n        );\n      continue;\n    }\n    findings\n      .get(definition.id)\n      ?.push(...narrowDefinition(definition, descriptor, kinds).findings);\n  }\n  return said.flatMap(({ definition }) =>\n    [\n      ...(findings.get(definition.id) ?? []),\n      // Judged as the engine's registry judges it — against the definitions\n      // as declared — so a host's test says what the application's start\n      // says (`onIssue`). The narrowing's own findings are above.\n      ...validateDefinition(definition, kinds, {\n        limits,\n        definitions: id => declared.get(id),\n      }),\n    ].map(found => ({ ...found, definition: definition.id })),\n  );\n}\n","/*\n * Copyright [2021-present] [ahoo wang <ahoowang@qq.com> (https://github.com/Ahoo-Wang)].\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *      http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { FieldOption, RecordKey } from '../model/index.js';\nimport {\n  actionState,\n  choiceOf,\n  confirmOf,\n  asksFirst,\n  initialInput,\n  missingInput,\n  nextChange,\n  offeredAt,\n  refusalsByReason,\n  runOne,\n  splitFor,\n  type ActionConfirm,\n  type ActionInput,\n  type ActionPlace,\n  type ActionRefusal,\n  type ActionRow as RecordRow,\n  type RecordAction,\n  type RecordActions,\n} from '../runtime/actions.js';\n\nexport interface ActionHarnessOptions {\n  /** The clock the rules are asked at; `Date.now()` when left out. */\n  now?: number;\n}\n\n/** One action on one record, as the row, the menu and the detail draw it. */\nexport interface HarnessState {\n  hidden: boolean;\n  available: boolean;\n  /** Why not, as the host wrote it (a key stays a key); `null` when able. */\n  reason: string | null;\n}\n\n/** One action over a selection, as the selection's bar and its dialog read it. */\nexport interface HarnessBulk {\n  able: RecordKey[];\n  refused: ActionRefusal[];\n  /** The refused by reason, the commonest first: what the dialog lists. */\n  reasons: { reason: string; count: number; keys: RecordKey[] }[];\n}\n\n/** One field of an action's form, as the dialog draws it. */\nexport interface HarnessField {\n  name: string;\n  label: string;\n  input: 'select' | 'text' | 'number' | 'boolean';\n  options: readonly FieldOption[] | null;\n  required: boolean;\n}\n\n/**\n * A host's declared actions over some records, without a screen\n * (host-integration.md 6): the engine's own reading of them — which place\n * offers which, whether a record takes one now and why not, how a\n * selection splits, what the confirmation and the form ask, when the rules\n * change on their own — so a host's unit test pins its business rules in a\n * line each.\n */\nexport interface ActionHarness {\n  /** Every action's id, in the order declared. */\n  readonly ids: readonly string[];\n  /** The ids offered at a place, in order. */\n  at(place: ActionPlace): string[];\n  /**\n   * One record's state; with an input, asked as a pressed action is — the\n   * form's `initial` under it.\n   */\n  state(id: string, key: RecordKey, input?: ActionInput): HarnessState;\n  bulk(\n    id: string,\n    keys?: readonly RecordKey[],\n    input?: ActionInput,\n  ): HarnessBulk;\n  /**\n   * Whether pressing it at `place` asks before sending — a selection\n   * always does — and what it asks: the declared question, or `null` when\n   * the engine asks with its own words (a selection with no `confirm`).\n   * Asked as the screen asks it: the form's `initial` under `input`.\n   */\n  asks(\n    id: string,\n    place: ActionPlace,\n    input?: ActionInput,\n  ): { asks: boolean; confirm: ActionConfirm | null };\n  /** The form's fields, or `null` without one; a choice is one `select`. */\n  form(id: string): HarnessField[] | null;\n  /** Whether it is a choice: a form of one field of options, offered as them. */\n  choice(id: string): readonly FieldOption[] | null;\n  /** The required fields `input` leaves blank, the form's `initial` under it. */\n  missing(id: string, input: ActionInput): string[];\n  /** The soonest time after `now` a record's availability flips on its own. */\n  changesAt(key?: RecordKey): number | null;\n  /**\n   * Sends one record the command as the engine would — with the form's\n   * `initial` under `input` — refused with the reason (`ActionRefusedError`)\n   * where it does not take it, else the host's `run` itself.\n   */\n  run(id: string, key: RecordKey, input?: ActionInput): Promise<unknown>;\n}\n\nexport function actionHarness(\n  list: RecordActions,\n  rows: readonly RecordRow[],\n  { now = Date.now() }: ActionHarnessOptions = {},\n): ActionHarness {\n  const byKey = new Map(rows.map(row => [row.key, row]));\n  const find = (id: string): RecordAction => {\n    const action = list.find(each => each.id === id);\n    if (!action) throw new Error(`No action \"${id}\".`);\n    return action;\n  };\n  // What a press starts from: the form's `initial`, the given input over it.\n  const pressed = (action: RecordAction, input: ActionInput = {}) => ({\n    ...initialInput(action),\n    ...input,\n  });\n  const rowOf = (key: RecordKey): RecordRow => {\n    const row = byKey.get(key);\n    if (!row) throw new Error(`No record \"${String(key)}\".`);\n    return row;\n  };\n  return {\n    ids: list.map(action => action.id),\n    at: place => offeredAt(list, place).map(action => action.id),\n    state: (id, key, input) => {\n      const action = find(id);\n      return actionState(\n        action,\n        rowOf(key),\n        input ? { now, input: pressed(action, input) } : { now },\n      );\n    },\n    bulk(id, keys = rows.map(row => row.key), input) {\n      const action = find(id);\n      const split = splitFor(\n        action,\n        keys,\n        key => byKey.get(key),\n        input ? { now, input: pressed(action, input) } : { now },\n      );\n      return {\n        ...split,\n        reasons: refusalsByReason(split.refused).map(({ reason, keys }) => ({\n          reason,\n          count: keys.length,\n          keys,\n        })),\n      };\n    },\n    asks(id, place, input) {\n      const action = find(id);\n      const given = pressed(action, input);\n      return {\n        asks: asksFirst(action, place, given),\n        confirm: confirmOf(action, given),\n      };\n    },\n    form(id) {\n      const form = find(id).form;\n      if (!form) return null;\n      return Object.entries(form).map(([name, field]) => ({\n        name,\n        label: field.label,\n        input: field.options ? 'select' : (field.input ?? 'text'),\n        options: field.options ?? null,\n        required: field.required !== false,\n      }));\n    },\n    choice: id => choiceOf(find(id))?.options ?? null,\n    missing: (id, input) => {\n      const action = find(id);\n      return missingInput(action, pressed(action, input));\n    },\n    changesAt: key =>\n      nextChange(list, key === undefined ? rows : [rowOf(key)], now),\n    run: (id, key, input) => {\n      const action = find(id);\n      return runOne(action, byKey.get(key), pressed(action, input), now);\n    },\n  };\n}\n"],"mappings":"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"}