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

package/dist/model/field.d.ts

@@ -0,0 +1,432 @@
+import { SearchMode, StringComparison } from '@ahoo-wang/wow-client';
+import { FilterOperatorName } from './filter.js';
+/**
+ * Identifies a `FieldKind`: the package registers the built-in ones and an
+ * application may register its own, so this stays an open string union.
+ */
+export type FieldKindId = BuiltinFieldKindId | (string & {});
+export type BuiltinFieldKindId = 'string' | 'number' | 'boolean' | 'date' | 'datetime' | 'enum' | 'reference' | 'array' | 'elementMatch' | 'search' | MetadataFieldKindId;
+/**
+ * Kinds backed by Wow's metadata filters rather than by a document field.
+ *
+ * Whether one of these is a legitimate condition depends on who is looking: a
+ * user narrows to their own documents by owner or to a workspace by space, a
+ * platform operator narrows to a tenant. That judgement belongs to the
+ * definition, which is code and ships per application, so the engine offers
+ * the kinds and lets each definition decide which of them a view may use.
+ */
+export type MetadataFieldKindId = 'documentId' | 'aggregateId' | 'tenantId' | 'ownerId' | 'spaceId'
+/** Whether soft-deleted records are shown: Wow's `DELETION` filter (D17-2). */
+ | 'deletion';
+/**
+ * Kinds whose `name` is a handle for the editor and the label rather than a
+ * path into a document. They compile to a filter that names no field, so the
+ * presence questions — which do carry one — are not theirs to answer.
+ */
+export declare const FIELDLESS_FIELD_KIND_IDS: readonly FieldKindId[];
+/**
+ * Whether a kind's `name` is a handle rather than a path into a document.
+ *
+ * Three things follow from it and each one is a place the two were confused:
+ * the presence operators do not apply, the field is not a record column, and
+ * Wow refuses such a filter inside an element predicate — it calls them root
+ * filters, and its list is exactly this one.
+ *
+ * The registered kind answers first when the caller has one: a custom kind
+ * that compiles to a root filter declares `fieldless` on itself, and an id
+ * list here could never have heard of it. The list stays the answer for a
+ * kind nobody has resolved — a record column asked about by id alone.
+ */
+export declare function isFieldlessKind(kind: FieldKindId, registered?: {
+    fieldless?: boolean;
+}): boolean;
+/**
+ * Whether one record holds at most one string in this field.
+ *
+ * Two answers make it up, because two declarations can make it false. The
+ * kind says what shape its values have; the field's own candidates say what
+ * those values are, and a closed set of numeric codes is a numeric field
+ * whatever its kind is called — `enum` over `[1, 2]` is stored as numbers,
+ * and a sentinel bucket over it is refused by Wow rather than by us.
+ */
+export declare function isSingleStringField(field: FieldDefinition, registered?: {
+    singleString?: boolean;
+}): boolean;
+export declare const METADATA_FIELD_KIND_IDS: readonly MetadataFieldKindId[];
+export declare const BUILTIN_FIELD_KIND_IDS: readonly BuiltinFieldKindId[];
+export declare function isFieldName(name: string): boolean;
+/**
+ * A field path as one alias segment, injectively.
+ *
+ * Wow takes a single-segment alias only, so a path has to lose its dots. A
+ * plain `.`→`_` made `a.b` and `a_b` the same alias, and whichever cell came
+ * second overwrote the first — silently, because both are legal aliases and
+ * the server answers with one value under one name. Doubling an existing `_`
+ * first keeps the mapping reversible: a lone `_` is always a `.` that was.
+ */
+export declare function fieldAliasSegment(field: string): string;
+/**
+ * What a badge says about the value it wraps, beyond naming it.
+ *
+ * Closed, and named after the meaning rather than after a colour: which of a
+ * definition's own statuses is good news is business knowledge the renderer
+ * cannot guess, but which colour good news wears is the theme's, and a
+ * definition that could write `#22c55e` here would be painting into it. Each
+ * tone maps to a token the surface already carries, so a host that restyles
+ * `--fve-success` restyles every badge wearing it.
+ */
+export type FieldTone = 'neutral' | 'success' | 'warning' | 'danger';
+export declare const FIELD_TONES: readonly FieldTone[];
+/** A selectable value: static for `enum`, resolved for `reference`. */
+export interface FieldOption {
+    value: string | number;
+    label: string;
+    group?: string;
+    disabled?: boolean;
+    /** How a badge for this choice reads; neutral when the option names none. */
+    tone?: FieldTone;
+}
+/**
+ * How a cell reads.
+ *
+ * Closed, because `/ui` has no renderer registry: `RecordTable` switches over
+ * this union, so a key nothing switches on would silently fall through to the
+ * default rendering — a URL as a string of characters, an array as a comma
+ * join. Definition admission refuses an unknown one instead, which is the
+ * same rule every capability follows: what the engine offers is what a
+ * definition may ask for.
+ *
+ * Six of them are the kinds' own renderings, writable here so a field may
+ * borrow one: a number holding a millisecond instant reads as a date under
+ * `cell: 'date'`. The other five are readings no kind implies — one badge, a
+ * badge per entry, an external link, a paragraph, and a value with the means
+ * to take it away.
+ */
+export type FieldCellId = 'string' | 'number' | 'boolean' | 'date' | 'datetime' | 'enum' | 'status' | 'tags' | 'link' | 'text' | 'copyable';
+export declare const FIELD_CELL_IDS: readonly FieldCellId[];
+/**
+ * Whether cells under this reading are moments rather than numbers or words.
+ *
+ * It asks about the **reading** and not about the kind, because the reading
+ * is what the column shows: `cell: 'date'` over a number holding an epoch
+ * instant draws a column of dates, and the summary under it has to be one
+ * too. It takes a plain string, since a reading travels as one — a projected
+ * column's `cell`, a summary cell's — and an application may register a kind
+ * whose id this list has never heard of.
+ */
+export declare function isDateCell(cell: string | undefined): boolean;
+/** Row-level aggregations a record view may show under a column. */
+export type SummaryFunction = 'SUM' | 'AVG' | 'MIN' | 'MAX' | 'COUNT';
+export declare const SUMMARY_FUNCTIONS: readonly SummaryFunction[];
+/**
+ * The summaries a column of moments may carry.
+ *
+ * A date has an earliest, a latest and a count; it has no sum and no
+ * average. Adding two instants answers nothing at all, and the mean of two
+ * order times is a moment no order was placed at — a number the aggregation
+ * would happily return and that no reader could use. So the maths is left
+ * out of the set rather than shown and then explained.
+ */
+export declare const DATE_SUMMARY_FUNCTIONS: readonly SummaryFunction[];
+/**
+ * The summaries a field really offers: what it declares, less what its own
+ * values cannot answer.
+ *
+ * One rule, read in both places that need it — admission, which refuses a
+ * summary outside the set (`record.summary.unsupported`), and the column
+ * settings' select, which must stop offering exactly where admission starts
+ * refusing. A definition declaring `SUM` on a date field is a mistake in
+ * code, so it is refused rather than obeyed; declaring `MIN` and `MAX` there
+ * is how a column gets its earliest and its latest.
+ */
+export declare function summaryFunctionsOf(field: FieldDefinition): readonly SummaryFunction[];
+/**
+ * How a time field keeps its time, which is how a condition on it has to
+ * write one — Wow's own `QuerySemanticType` for time, named as Wow names it.
+ *
+ * - `epoch` is Wow's `TEMPORAL_EPOCH`: an integer count of `timeUnit` since
+ *   the epoch, milliseconds when unsaid. Every time a Wow snapshot carries —
+ *   `eventTime`, `firstEventTime`, an aggregate's `@QueryTemporal` longs — is
+ *   one, and Wow's schema validation refuses anything but an integer there.
+ * - `date` is Wow's `TEMPORAL_DATE`: the store's own date type, which a query
+ *   names in ISO 8601 text.
+ *
+ * Wow's third, `TEMPORAL_FORMATTED`, a string under a pattern, is not
+ * modelled: no definition has needed one, and a bound written under the
+ * wrong pattern would be compared as text and match the wrong rows quietly.
+ */
+export type FieldTemporal = EpochTemporal | DateTemporal;
+export interface EpochTemporal {
+    type: 'epoch';
+    /** Wow's `timeUnit`; milliseconds when unsaid, as Wow's own default is. */
+    timeUnit?: EpochTimeUnit;
+}
+export interface DateTemporal {
+    type: 'date';
+}
+/** The units of `TimeUnit` an epoch time is kept in, as Wow spells them. */
+export type EpochTimeUnit = 'MILLISECONDS' | 'SECONDS';
+export declare const EPOCH_TIME_UNITS: readonly EpochTimeUnit[];
+export declare const TEMPORAL_TYPES: readonly FieldTemporal['type'][];
+/** The kinds whose conditions write a time, and so may declare `temporal`. */
+export declare const TEMPORAL_FIELD_KIND_IDS: readonly FieldKindId[];
+/**
+ * How finely a table cell writes a time of day (`FieldDefinition.timePrecision`).
+ *
+ * - `minute`, the default: a column of times is read for when something
+ *   happened, and the seconds made every such column some 180 pixels wide —
+ *   the largest source of sideways scrolling in a record workbench (second
+ *   review R2-23). The cell drops the year within the current one, too.
+ * - `second`: for a field whose seconds are the point, an event stream's
+ *   times above all, where two events a few seconds apart are the story.
+ *
+ * Only the table's cell is short. Its title, the record's detail, a card and
+ * a file keep the whole time, seconds included.
+ */
+export type TimePrecision = 'minute' | 'second';
+export declare const TIME_PRECISIONS: readonly TimePrecision[];
+/**
+ * What a time field that declares nothing is: epoch milliseconds.
+ *
+ * The default is the engine's audience rather than the fixtures' habit. A
+ * Wow snapshot keeps every time as epoch milliseconds, and a definition
+ * written from a Wow query schema should come out right without the author
+ * having to remember one more member on each of them; a store that keeps a
+ * native date is the case that says so.
+ */
+export declare const DEFAULT_TEMPORAL: Required<EpochTemporal>;
+/** How this field keeps its time: its declaration, or the default. */
+export declare function temporalOf(field: FieldDefinition): FieldTemporal;
+/**
+ * The unit this field's epoch numbers count in, where it is not the
+ * default milliseconds — `undefined` for milliseconds and for a field that
+ * keeps no epoch at all. What reads a value as a time (`readInstant`) takes
+ * it, so a cell, a footer and an earliest agree with the condition that
+ * wrote the time in that unit.
+ */
+export declare function epochUnitOf(field: Pick<FieldDefinition, 'kind' | 'cell' | 'temporal'>): EpochTimeUnit | undefined;
+/**
+ * What a number field's value is, beyond a number — Wow's numeric
+ * `QuerySemanticType` (#3552), named as the engine names things: how many
+ * digits it is kept to, and for an amount of money, whose money it is.
+ *
+ * - `decimal` is Wow's `DECIMAL`: a fixed-point number with `scale` digits
+ *   after the point, written with exactly that many.
+ * - `money` is Wow's `MONEY`: an amount in one currency, `scale` digits
+ *   after the point, and the currency either fixed for the whole field (an
+ *   ISO 4217 `currency`) or held per record by a sibling string field
+ *   (`currencyField`, a property of the same object or element) — so an
+ *   amount reads in its own currency, and amounts in different currencies
+ *   are never added up as if they were one.
+ *
+ * Narrowing writes it from the source's descriptor where the definition
+ * says nothing; a definition may declare it itself. It decides how the
+ * value reads only where the field declares no `numberFormat` — the
+ * author's own format wins (`numberFormatOf`).
+ */
+export type FieldNumeric = DecimalNumeric | FixedMoneyNumeric | RowMoneyNumeric;
+export interface DecimalNumeric {
+    type: 'decimal';
+    /** Digits after the decimal point, 0 or more. */
+    scale: number;
+}
+export interface FixedMoneyNumeric {
+    type: 'money';
+    /** Digits after the decimal point, 0 or more. */
+    scale: number;
+    /** The ISO 4217 code every value of the field is in, such as `CNY`. */
+    currency: string;
+    currencyField?: undefined;
+}
+export interface RowMoneyNumeric {
+    type: 'money';
+    /** Digits after the decimal point, 0 or more. */
+    scale: number;
+    currency?: undefined;
+    /**
+     * The sibling property holding each value's ISO 4217 code: its name
+     * beside the amount, not a path from the root — `currency` beside
+     * `price.amount` is `price.currency` (`currencyPathOf`).
+     */
+    currencyField: string;
+}
+export declare const NUMERIC_TYPES: readonly FieldNumeric['type'][];
+/** The most fraction digits Intl writes, which `scale` is held under. */
+export declare const MAX_NUMERIC_SCALE = 20;
+/** An ISO 4217 currency code: three letters. */
+export declare const CURRENCY_CODE_PATTERN: RegExp;
+/**
+ * How a number of this field is written: the author's `numberFormat` when
+ * the field declares one, otherwise what its `numeric` says — `scale`
+ * fraction digits, and for money in one fixed currency, that currency.
+ * Money whose currency is held per record gets the digits here and its
+ * currency where the record is read (`currencyPathOf`), since no one
+ * format is true of every value.
+ *
+ * It is the one place the two meet, so every reader — a cell, a column, a
+ * metric, an axis — prints what the others print.
+ */
+export declare function numberFormatOf(field: Pick<FieldDefinition, 'numberFormat' | 'numeric'> | undefined): NumberFormat | undefined;
+/**
+ * Where the currency of this field's values is held, for money whose
+ * currency is per record: the sibling `currencyField` beside the field's
+ * own name — `price.currency` for `price.amount`, `currency` for `amount`.
+ * `undefined` for every other field, the author's own `numberFormat`
+ * included: a field formatted by its author reads as the author said.
+ * `path` is where the field is named from, when that is not its own name —
+ * an element's field as an analysis spells it from the root.
+ */
+export declare function currencyPathOf(field: Pick<FieldDefinition, 'name' | 'numberFormat' | 'numeric'>, path?: string): string | undefined;
+/**
+ * The aggregate functions a field really offers an analysis: what its
+ * capability declares, less what its own values cannot answer — the
+ * analysis side of `summaryFunctionsOf`, read by the analysis scope, so
+ * admission, the tray's summary select and a fresh config's first metric all
+ * stop at the same place. A field the scope cannot find keeps what it
+ * declares; admission reports the field itself.
+ */
+export declare function aggregationFunctionsOf<F extends string>(field: Pick<FieldDefinition, 'kind' | 'cell'> | undefined, declared: readonly F[]): F[];
+/** Formatting shared by cells, summaries and chart axes. */
+export type NumberFormat = Intl.NumberFormatOptions & {
+    locale?: string;
+};
+/**
+ * One queryable field of a definition. Declared in code, so it may use the
+ * Wow operator enum directly; stored configs use the literal form instead.
+ */
+export interface FieldDefinition {
+    /** Wow query field path, e.g. `warehouse` or `address.city`. */
+    name: string;
+    label: string;
+    kind: FieldKindId;
+    /** Narrows the kind's default operator set. */
+    operators?: FilterOperatorName[];
+    /** Static candidates for `enum`. */
+    options?: FieldOption[];
+    /** Remote candidate source key for `reference`, resolved by the engine. */
+    remote?: string;
+    sortable?: boolean;
+    /**
+     * How a number of this field is written; it wins over what `numeric`
+     * would say.
+     */
+    numberFormat?: NumberFormat;
+    /**
+     * What a number of this field is (`FieldNumeric`): a fixed-point decimal,
+     * or money in a fixed currency or in one each record holds. Written by
+     * narrowing from the descriptor's `semantic` where the definition says
+     * nothing (#3552).
+     */
+    numeric?: FieldNumeric;
+    /** Summary functions this field allows. */
+    summary?: SummaryFunction[];
+    /**
+     * For an array of objects whose elements differ by variant — an event
+     * stream's `body`, whose payload depends on `bodyType` — the element's
+     * field that names each element's variant (#3519, written by narrowing).
+     * A condition in the array's predicate on a field only some variants
+     * have is compiled together with a condition on this one, so both hold
+     * for the same element.
+     */
+    variantKey?: string;
+    /**
+     * For a field of such an element, the variants that have it, by the
+     * value their `variantKey` holds (written by narrowing).
+     */
+    variants?: string[];
+    /**
+     * Set when the source deprecates the field (its descriptor's
+     * `deprecated`, #3519): still offered and queried, with the reason, so a
+     * reader and an author move off it. A definition may say it too.
+     */
+    deprecated?: {
+        message?: string;
+    };
+    /**
+     * Whether a stored `null` or empty value reads as missing on the source
+     * (`NULL_OR_EMPTY_AS_MISSING`, #3515): a presence condition then asks
+     * "has a non-empty value", not "has the key", and says so.
+     */
+    emptyIsMissing?: boolean;
+    /**
+     * Whether a page may ask its source for this field. Left out, it may; a
+     * source whose descriptor says it cannot be projected answers `false`
+     * here, and a column of it reads empty rather than the page being refused.
+     */
+    projectable?: boolean;
+    /** How the cell reads; defaults to the kind's own renderer. */
+    cell?: FieldCellId;
+    /**
+     * For a `date` or `datetime` field, how the store keeps its time, and so
+     * how a condition's bounds are written: epoch milliseconds when unsaid
+     * (`DEFAULT_TEMPORAL`). Copy it from the field's `semanticType` in the Wow
+     * query schema.
+     */
+    temporal?: FieldTemporal;
+    /**
+     * For a field read as a `datetime`, how finely a table cell writes the time
+     * of day: to the minute when unsaid, `'second'` for a field whose seconds
+     * matter (`TimePrecision`). The cell's title and the record's detail always
+     * say the seconds.
+     */
+    timePrecision?: TimePrecision;
+    /**
+     * For an array of objects, what each of its elements holds.
+     *
+     * It belongs to the field because it describes that field: `items` is the
+     * array, and these are what it contains. Declared anywhere else it would be
+     * linked back by a path string, which can name a field that does not exist —
+     * a whole class of dangling reference that simply cannot be written here.
+     *
+     * An element's names are its own scope and may repeat a root field's,
+     * because every reference to one is written `field.element`.
+     */
+    elements?: FieldDefinition[];
+    /**
+     * For an array of objects, the element field that names one element — the
+     * name it has within `elements`. A cell reads the array as its elements,
+     * each by this field and the way this field reads: an enum's label and
+     * tone as a badge, a string as its text.
+     *
+     * Called a title because it is one, in the same sense as a card's title
+     * (`RecordCardSpec.title`): the one value that says which thing this is.
+     * The engine cannot pick it — an event history is read by `name`, an
+     * order line by `sku`, and which member says what an element *is* is
+     * business knowledge — and without it an array of objects reads as how
+     * many elements it holds, never as the JSON of them. Admission refuses a
+     * name `elements` does not declare, and an element field that holds no
+     * value of its own (a handle, or a further array of objects).
+     */
+    elementTitle?: string;
+    /**
+     * How `CONTAINS`, `STARTS_WITH` and `ENDS_WITH` compare text on this field.
+     *
+     * The default is case-insensitive, because somebody filtering a list by
+     * typing `beijing` means to find `Beijing`. A field where case carries
+     * meaning — a product code, a signature, anything the user is matching
+     * exactly rather than searching — pins itself to `CASE_SENSITIVE` here.
+     * Wow attaches this to text matching only: `EQ` and `IN` have no such
+     * option, so neither does this.
+     */
+    stringComparison?: StringComparisonName;
+    /**
+     * For a `search` field, which fields the query looks in. Omitted, it looks
+     * wherever the backend indexes — which is what a search box usually means.
+     */
+    searchFields?: string[];
+    /**
+     * For a `search` field, whether the query is a set of words or one phrase.
+     * Like `stringComparison`, how matching works is a property of the field;
+     * the value is only what the user typed.
+     */
+    searchMode?: SearchModeName;
+}
+/** Wow's `SearchMode`, as the literal a definition writes. */
+export type SearchModeName = `${SearchMode}`;
+export declare const SEARCH_MODES: readonly SearchModeName[];
+export declare const DEFAULT_SEARCH_MODE: SearchModeName;
+/** Wow's `StringComparison`, as the literal a definition writes. */
+export type StringComparisonName = `${StringComparison}`;
+export declare const DEFAULT_STRING_COMPARISON: StringComparisonName;
+export declare const STRING_COMPARISONS: readonly StringComparisonName[];
+//# sourceMappingURL=field.d.ts.map

package/dist/model/field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../src/model/field.ts"],"names":[],"mappings":"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"}

package/dist/model/filter.d.ts

@@ -0,0 +1,54 @@
+import { FilterOperator } from '@ahoo-wang/wow-client';
+import { JsonValue } from './json.js';
+/**
+ * Operator name as stored in a configuration: the same values as Wow's
+ * `FilterOperator`, as string literals, so a config stays plain JSON.
+ */
+export type FilterOperatorName = `${FilterOperator}`;
+/**
+ * The scope of a view, shared by all three kinds. Depth and node count are
+ * bounded by `RuntimeLimits`, because a tree arrives from a store.
+ */
+export type FilterTree = FilterGroup;
+/**
+ * How a group combines its children, as the same three Wow spells `AND`,
+ * `OR` and `NOR`. `nor` means none of the children match, which is the only
+ * way to express a negation here: leaves negate through their operator, and a
+ * group has no operator of its own to negate with.
+ */
+export type FilterGroupOperator = 'and' | 'or' | 'nor';
+/**
+ * The three, in the order a group's select offers them.
+ *
+ * One list, beside the type it spells out: the select in a group's header,
+ * the menu that nests a new group and the admission of a tree from a store
+ * all have to agree on which operators exist, and three copies of
+ * `['and', 'or', 'nor']` is three chances for one of them to be behind.
+ */
+export declare const FILTER_GROUP_OPERATORS: readonly FilterGroupOperator[];
+/**
+ * Whether a value is one of the three. A tree arrives from a store and a
+ * select hands back a string, so both ask here rather than spelling the
+ * list out again as a chain of comparisons.
+ */
+export declare function isFilterGroupOperator(value: unknown): value is FilterGroupOperator;
+export interface FilterGroup {
+    op: FilterGroupOperator;
+    children: FilterNode[];
+}
+export interface FilterLeaf {
+    /** Field name as declared by the definition, or a dashboard global field. */
+    field: string;
+    operator: FilterOperatorName;
+    value: FilterValue;
+}
+export type FilterNode = FilterGroup | FilterLeaf;
+/**
+ * The semantic value of a leaf. Its shape belongs to the field's `FieldKind`
+ * (see the `filter` layer), never to a compiled query: "last 7 days" is stored
+ * as a relative intent and evaluated at execution time.
+ */
+export type FilterValue = JsonValue;
+/** `simple` mode only admits a single AND group whose children are all leaves. */
+export type FilterMode = 'simple' | 'advanced';
+//# sourceMappingURL=filter.d.ts.map

package/dist/model/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/model/filter.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,GAAG,cAAc,EAAE,CAAC;AAErD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC;AAErC;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,CAAC;AAEvD;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,mBAAmB,EAIhE,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,mBAAmB,CAE9B;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,mBAAmB,CAAC;IACxB,QAAQ,EAAE,UAAU,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACzB,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,KAAK,EAAE,WAAW,CAAC;CACpB;AAED,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,UAAU,CAAC;AAElD;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,CAAC;AAEpC,kFAAkF;AAClF,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,UAAU,CAAC"}

package/dist/model/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Types and constants only: the three facts of `docs/design/README.md` say
+ * definitions are code, configs are data and runtime state is transient, so
+ * this layer describes the first two and depends on nothing else.
+ */
+export * from './analysis.js';
+export * from './chart.js';
+export * from './config.js';
+export type { CurrencyReading } from './currency.js';
+export * from './dashboard.js';
+export * from './definition.js';
+export * from './field.js';
+export * from './filter.js';
+export * from './instance.js';
+export * from './issue.js';
+export * from './json.js';
+export * from './limits.js';
+export * from './record.js';
+export * from './storeError.js';
+export * from './text.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/model/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/model/index.ts"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAE5B,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC"}

package/dist/model/instance.d.ts

@@ -0,0 +1,118 @@
+import { ViewConfig, ViewKind } from './config.js';
+/**
+ * Who configured a view, who sees it and who may change it.
+ *
+ * - `system`: developers or operators; read-only for everyone else — but a
+ *   system view a store keeps (`stored`) is edited by whoever the host lets
+ *   (`ViewPermissions.editSystem`, D81).
+ * - `shared`: a user with permission; visible across the definition.
+ * - `personal`: its owner only.
+ *
+ * These are the legal combinations of two facts — who a view is for, and
+ * whether it came from a user — rather than one dimension. A system view is
+ * always a shared view, and a personal system view is not a thing; holding
+ * the pair as a single value is what makes that last sentence impossible to
+ * write down instead of a rule somebody has to enforce. `audienceOf` and
+ * `isSystemScope` read the two facts back out, and every caller asks through
+ * them rather than comparing the value itself — a `scope !== 'personal'`
+ * spelled out at the point of use is this rule, restated where nobody can
+ * see it is the same rule.
+ */
+export type ViewScope = 'system' | 'shared' | 'personal';
+export declare const VIEW_SCOPES: readonly ViewScope[];
+/** Who a view is for. A system view is a shared view; see `ViewScope`. */
+export type ViewAudience = 'personal' | 'shared';
+/**
+ * The two, in the order every list of views shows them in: personal above
+ * shared. The sidebar, the switcher's menu and the manager's dialog are three
+ * views of one list, so the order is the model's rather than each of theirs.
+ */
+export declare const VIEW_AUDIENCES: readonly ViewAudience[];
+/** The audience a scope puts a view in: `system` answers `shared`. */
+export declare function audienceOf(scope: ViewScope): ViewAudience;
+/** Whether the view was configured for everyone rather than by a user. */
+export declare function isSystemScope(scope: ViewScope): boolean;
+/** A saved config plus its identity. Only configs persist, never results. */
+export interface ViewInstance {
+    id: string;
+    definitionId: string;
+    title: string;
+    scope: ViewScope;
+    /** Opaque; compared for equality only. Code-declared system views use `code`. */
+    revision: string;
+    config: ViewConfig;
+    /**
+     * Set by a store on a system view it keeps and can write (D81): an admin
+     * saved, renamed or published it there, and may save, rename and delete
+     * it again when the host grants `ViewPermissions.editSystem`. Absent on
+     * every other view — a system view declared in code (`system:` ids) or
+     * in the backend's configuration stays read-only whatever is granted.
+     */
+    stored?: true;
+}
+/** Revision of a system view that ships with the definition. */
+export declare const CODE_REVISION = "code";
+/**
+ * The longest title a saved view may have, counted in UTF-16 code units
+ * after trimming. One rule on both sides of the port: the server's
+ * `ViewConfigs.MAX_TITLE_LENGTH` (`view-store/wow-view-store-domain`) is
+ * the source, this mirrors it (`test/storeLimits.test.ts` reads both), the
+ * engine refuses a longer one before sending (`view.title.too-long`), and
+ * `MemoryViewStore` refuses it as the server does.
+ */
+export declare const MAX_VIEW_TITLE_LENGTH = 120;
+/**
+ * The largest config a saved view may store, in UTF-8 bytes of its JSON:
+ * the server's `ViewConfigs.MAX_CONFIG_BYTES`, mirrored as the title's
+ * limit is — below the 256 KB request body a WebFlux server buffers by
+ * default, so the server's refusal is the one a larger config meets.
+ */
+export declare const MAX_VIEW_CONFIG_BYTES: number;
+/**
+ * What is wrong with a view's title, if anything: blank once trimmed, or
+ * longer than `MAX_VIEW_TITLE_LENGTH`. A title is stored trimmed.
+ */
+export declare function titleProblem(title: string): 'empty' | 'too-long' | null;
+/** The size a config is stored at: the UTF-8 bytes of its JSON. */
+export declare function configBytes(config: ViewConfig): number;
+/**
+ * What a list returns: enough to render the sidebar, without the config.
+ *
+ * It is not "an instance minus its config": `kind` is the config's own tag,
+ * projected, because one data definition holds record and analysis views
+ * together and a list has to tell them apart. A store answering `list` reads
+ * it off the config it stores — it never records a second copy, which could
+ * then disagree with the config it names.
+ */
+export interface ViewInstanceSummary {
+    id: string;
+    definitionId: string;
+    title: string;
+    scope: ViewScope;
+    /** Always equal to the `kind` of the config this summary names. */
+    kind: ViewKind;
+    revision: string;
+    /** A system view the store keeps and can write; see `ViewInstance.stored`. */
+    stored?: true;
+}
+/** What a list shows: an instance without the config it holds. */
+export declare function toSummary(instance: ViewInstance): ViewInstanceSummary;
+/** One user's ordering and default view for one definition. */
+export interface ViewPreferences {
+    /** Explicitly ordered instance ids; unlisted ones follow in server order. */
+    order: string[];
+    defaultInstanceId: string | null;
+    /**
+     * Whether an analysis runs again on its own as its question is edited
+     * (D20 改了就跑); on when unsaid. The range still waits for Apply.
+     */
+    autoRun?: boolean;
+    /**
+     * The tab this reader last read each dashboard of the definition on, by
+     * instance id (D22 E). The reader's, never the board's: a board's config
+     * holds its tabs, not where anyone is on them.
+     */
+    lastTabs?: Record<string, string>;
+    revision: string;
+}
+//# sourceMappingURL=instance.d.ts.map

package/dist/model/instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../../src/model/instance.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAExD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEzD,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAI3C,CAAC;AAEF,0EAA0E;AAC1E,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEjD;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,YAAY,EAA2B,CAAC;AAE9E,sEAAsE;AACtE,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,YAAY,CAEzD;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAEvD;AAED,6EAA6E;AAC7E,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,SAAS,CAAC;IACjB,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;IACnB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,IAAI,CAAC;CACf;AAED,gEAAgE;AAChE,eAAO,MAAM,aAAa,SAAS,CAAC;AAEpC;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAAa,CAAC;AAEhD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,GAAG,IAAI,CAIvE;AAED,mEAAmE;AACnE,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAOtD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,SAAS,CAAC;IACjB,mEAAmE;IACnE,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,MAAM,CAAC,EAAE,IAAI,CAAC;CACf;AAED,kEAAkE;AAClE,wBAAgB,SAAS,CAAC,QAAQ,EAAE,YAAY,GAAG,mBAAmB,CAWrE;AAED,+DAA+D;AAC/D,MAAM,WAAW,eAAe;IAC9B,6EAA6E;IAC7E,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;CAClB"}