@petrarca/sonnet-core 0.8.0 → 0.9.0

package/dist/search/index.d.ts

@@ -59,6 +59,16 @@ declare const EMPTY_FILTER: FilterExpr;
  * Ignores the boolean structure (AND / OR / NOT / GROUP).
  */
 declare function collectTerms(expr: FilterExpr): FilterTerm[];
+/**
+ * The value of the first term with `key`, or undefined -- for a facet used once.
+ * Ignores the boolean structure, like collectTerms.
+ */
+declare function termValue(expr: FilterExpr, key: string): string | undefined;
+/**
+ * The values of every term with `key`, in order -- for a repeatable facet.
+ * Ignores the boolean structure, like collectTerms.
+ */
+declare function termValues(expr: FilterExpr, key: string): string[];
 /**
  * Collect all term nodes from a FilterExpr tree as flat key/value pairs.
  *
@@ -115,5 +125,12 @@ declare function termsToFilterExpr(terms: {
     key: string;
     value: string;
 }[]): FilterExpr;
+/**
+ * A free text as a filter: the text in any of the fields -- one term per
+ * field, OR-ed -- or, without fields, the server's own `search` term. Empty
+ * text is no filter. What a search box sends for what is typed in it.
+ */
+declare function textSearchExpr(text: string, fields?: string[]): FilterExpr;
 
-export { EMPTY_FILTER, type FilterAnd, type FilterExpr, type FilterGroup, type FilterNot, type FilterOr, type FilterTerm, buildListParams, collectTerms, flattenFilterExpr, isEmptyFilterExpr, serializeFilterExpr, termsToFilterExpr };
+export { EMPTY_FILTER, buildListParams, collectTerms, flattenFilterExpr, isEmptyFilterExpr, serializeFilterExpr, termValue, termValues, termsToFilterExpr, textSearchExpr };
+export type { FilterAnd, FilterExpr, FilterGroup, FilterNot, FilterOr, FilterTerm };

package/dist/search/index.js

@@ -22,6 +22,12 @@ function collectTermNodes(expr, out) {
       break;
   }
 }
+function termValue(expr, key) {
+  return collectTerms(expr).find((t) => t.key === key)?.value;
+}
+function termValues(expr, key) {
+  return collectTerms(expr).filter((t) => t.key === key).map((t) => t.value);
+}
 function flattenFilterExpr(expr) {
   return collectTerms(expr).map(({ key, value }) => ({ key, value }));
 }
@@ -70,6 +76,22 @@ function termsToFilterExpr(terms) {
     }))
   };
 }
+function textSearchExpr(text, fields) {
+  const trimmed = text.trim();
+  if (!trimmed) return { type: "and", children: [] };
+  if (!fields?.length)
+    return {
+      type: "and",
+      children: [{ type: "term", key: "search", value: trimmed }]
+    };
+  const terms = fields.map(
+    (key) => ({ type: "term", key, value: trimmed })
+  );
+  return {
+    type: "and",
+    children: terms.length === 1 ? terms : [{ type: "or", children: terms }]
+  };
+}
 export {
   EMPTY_FILTER,
   buildListParams,
@@ -77,6 +99,9 @@ export {
   flattenFilterExpr,
   isEmptyFilterExpr,
   serializeFilterExpr,
-  termsToFilterExpr
+  termValue,
+  termValues,
+  termsToFilterExpr,
+  textSearchExpr
 };
 //# sourceMappingURL=index.js.map

package/dist/search/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/search/types.ts","../../src/search/filterExpr.ts"],"sourcesContent":["/**\n * FilterExpr -- lightweight boolean expression tree for search and filtering.\n *\n * Designed to start simple (a flat AND list of terms) and grow to support\n * full boolean queries (AND, OR, NOT, grouping) without breaking callers.\n *\n * The component always emits a FilterExpr. Callers that talk to a flat\n * server API today use flattenFilterExpr() to extract the terms. When the\n * server gains AST support, callers drop flattenFilterExpr and pass the\n * expression directly -- no component changes required.\n *\n * Extractable to @petrarca/sonnet-core: no app-specific imports.\n */\n\n/** A single field/value filter term -- the leaf node of a FilterExpr. */\nexport interface FilterTerm {\n  type: \"term\";\n  /** Schema property key -- used as the query param name sent to the server. */\n  key: string;\n  /** The filter value. */\n  value: string;\n}\n\n/** Conjunction: all children must match. */\nexport interface FilterAnd {\n  type: \"and\";\n  children: FilterExpr[];\n}\n\n/** Disjunction: at least one child must match. */\nexport interface FilterOr {\n  type: \"or\";\n  children: FilterExpr[];\n}\n\n/** Negation: child must not match. */\nexport interface FilterNot {\n  type: \"not\";\n  child: FilterExpr;\n}\n\n/**\n * Explicit grouping (parentheses). Semantically identical to its child --\n * used to preserve user intent when round-tripping the expression.\n */\nexport interface FilterGroup {\n  type: \"group\";\n  child: FilterExpr;\n}\n\n/** The full expression type. */\nexport type FilterExpr =\n  | FilterTerm\n  | FilterAnd\n  | FilterOr\n  | FilterNot\n  | FilterGroup;\n\n/** An empty expression -- no filters active. */\nexport const EMPTY_FILTER: FilterExpr = { type: \"and\", children: [] };\n","/**\n * Utilities for working with FilterExpr trees.\n *\n * Extractable to @petrarca/sonnet-core: no app-specific imports.\n */\n\nimport type { FilterExpr, FilterTerm } from \"./types\";\n\n/**\n * Return all term nodes from the expression as FilterTerm objects, depth-first.\n *\n * Ignores the boolean structure (AND / OR / NOT / GROUP).\n */\nexport function collectTerms(expr: FilterExpr): FilterTerm[] {\n  const out: FilterTerm[] = [];\n  collectTermNodes(expr, out);\n  return out;\n}\n\nfunction collectTermNodes(expr: FilterExpr, out: FilterTerm[]): void {\n  switch (expr.type) {\n    case \"term\":\n      out.push(expr);\n      break;\n    case \"and\":\n    case \"or\":\n      for (const child of expr.children) collectTermNodes(child, out);\n      break;\n    case \"not\":\n    case \"group\":\n      collectTermNodes(expr.child, out);\n      break;\n  }\n}\n\n/**\n * Collect all term nodes from a FilterExpr tree as flat key/value pairs.\n *\n * Use this when talking to a server API that accepts only flat key/value\n * filter params. When the server gains AST support, pass the raw FilterExpr\n * instead and drop this call.\n *\n * @example\n * const terms = flattenFilterExpr(expr);\n * // [{ key: \"name\", value: \"acme\" }, { key: \"status\", value: \"active\" }]\n * const params = Object.fromEntries(terms.map(t => [t.key, t.value]));\n */\nexport function flattenFilterExpr(\n  expr: FilterExpr,\n): { key: string; value: string }[] {\n  return collectTerms(expr).map(({ key, value }) => ({ key, value }));\n}\n\n/**\n * Return true when the expression contains no term nodes.\n */\nexport function isEmptyFilterExpr(expr: FilterExpr): boolean {\n  return collectTerms(expr).length === 0;\n}\n\n/**\n * Check whether a FilterExpr is a flat AND of terms only (no OR/NOT/Group).\n * When true, the expression can be serialized as simple key=value params.\n * When false, it must be serialized as a `q=` expression string.\n */\nfunction isFlatAnd(expr: FilterExpr): boolean {\n  if (expr.type === \"term\") return true;\n  if (expr.type === \"and\") return expr.children.every((c) => c.type === \"term\");\n  return false;\n}\n\n/**\n * Serialize a FilterExpr to the server's q= expression syntax.\n *\n * Produces strings like `code ~ \"aspirin\" OR display ~ \"aspirin\"`.\n * All terms use the `~` (LIKE / substring) operator -- the FilterTerm\n * type carries no operator field; callers that need exact-match or other\n * operators should construct the q= string directly.\n */\nexport function serializeFilterExpr(expr: FilterExpr): string {\n  switch (expr.type) {\n    case \"term\": {\n      const escaped = expr.value.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"');\n      return `${expr.key} ~ \"${escaped}\"`;\n    }\n    case \"and\":\n      return expr.children.map((c) => serializeFilterExpr(c)).join(\" AND \");\n    case \"or\":\n      return expr.children.map((c) => serializeFilterExpr(c)).join(\" OR \");\n    case \"not\":\n      return `NOT (${serializeFilterExpr(expr.child)})`;\n    case \"group\":\n      return `(${serializeFilterExpr(expr.child)})`;\n  }\n}\n\n/**\n * Build a typed API params object from a FilterExpr and pagination state.\n *\n * Used by list and expansion pages to convert Zustand store state into\n * query params for the server. The base object carries pagination keys\n * (limit / offset); filter terms from the expression are merged in.\n *\n * When the expression is a flat AND of terms, each term becomes a flat\n * query param (backwards compatible with existing server endpoints).\n * When the expression contains OR/NOT/Group nodes, it is serialized\n * as a `q=` string using the server's query expression syntax.\n *\n * @example\n * const params = buildListParams<ValueSetListParams>(\n *   filterExpr,\n *   { limit: pagination.pageSize, offset: pagination.pageIndex * pagination.pageSize },\n * );\n */\nexport function buildListParams<T extends object>(\n  expr: FilterExpr,\n  base: T,\n): T {\n  if (isEmptyFilterExpr(expr)) return base;\n\n  // Flat AND of terms: serialize as individual key=value params.\n  if (isFlatAnd(expr)) {\n    const pairs = flattenFilterExpr(expr);\n    const extra = Object.fromEntries(\n      pairs\n        .filter(({ key }) => !(key in base))\n        .map(({ key, value }) => [key, value]),\n    );\n    return { ...base, ...extra } as T;\n  }\n\n  // Complex expression: serialize as q= string.\n  return { ...base, q: serializeFilterExpr(expr) } as T;\n}\n\n/**\n * Build a flat AND expression from an array of key/value pairs.\n * Convenience for constructing the initial state from existing filter params.\n */\nexport function termsToFilterExpr(\n  terms: { key: string; value: string }[],\n): FilterExpr {\n  return {\n    type: \"and\",\n    children: terms.map((t) => ({\n      type: \"term\",\n      key: t.key,\n      value: t.value,\n    })),\n  };\n}\n"],"mappings":";AA2DO,IAAM,eAA2B,EAAE,MAAM,OAAO,UAAU,CAAC,EAAE;;;AC9C7D,SAAS,aAAa,MAAgC;AAC3D,QAAM,MAAoB,CAAC;AAC3B,mBAAiB,MAAM,GAAG;AAC1B,SAAO;AACT;AAEA,SAAS,iBAAiB,MAAkB,KAAyB;AACnE,UAAQ,KAAK,MAAM;AAAA,IACjB,KAAK;AACH,UAAI,KAAK,IAAI;AACb;AAAA,IACF,KAAK;AAAA,IACL,KAAK;AACH,iBAAW,SAAS,KAAK,SAAU,kBAAiB,OAAO,GAAG;AAC9D;AAAA,IACF,KAAK;AAAA,IACL,KAAK;AACH,uBAAiB,KAAK,OAAO,GAAG;AAChC;AAAA,EACJ;AACF;AAcO,SAAS,kBACd,MACkC;AAClC,SAAO,aAAa,IAAI,EAAE,IAAI,CAAC,EAAE,KAAK,MAAM,OAAO,EAAE,KAAK,MAAM,EAAE;AACpE;AAKO,SAAS,kBAAkB,MAA2B;AAC3D,SAAO,aAAa,IAAI,EAAE,WAAW;AACvC;AAOA,SAAS,UAAU,MAA2B;AAC5C,MAAI,KAAK,SAAS,OAAQ,QAAO;AACjC,MAAI,KAAK,SAAS,MAAO,QAAO,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM;AAC5E,SAAO;AACT;AAUO,SAAS,oBAAoB,MAA0B;AAC5D,UAAQ,KAAK,MAAM;AAAA,IACjB,KAAK,QAAQ;AACX,YAAM,UAAU,KAAK,MAAM,QAAQ,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAK;AACrE,aAAO,GAAG,KAAK,GAAG,OAAO,OAAO;AAAA,IAClC;AAAA,IACA,KAAK;AACH,aAAO,KAAK,SAAS,IAAI,CAAC,MAAM,oBAAoB,CAAC,CAAC,EAAE,KAAK,OAAO;AAAA,IACtE,KAAK;AACH,aAAO,KAAK,SAAS,IAAI,CAAC,MAAM,oBAAoB,CAAC,CAAC,EAAE,KAAK,MAAM;AAAA,IACrE,KAAK;AACH,aAAO,QAAQ,oBAAoB,KAAK,KAAK,CAAC;AAAA,IAChD,KAAK;AACH,aAAO,IAAI,oBAAoB,KAAK,KAAK,CAAC;AAAA,EAC9C;AACF;AAoBO,SAAS,gBACd,MACA,MACG;AACH,MAAI,kBAAkB,IAAI,EAAG,QAAO;AAGpC,MAAI,UAAU,IAAI,GAAG;AACnB,UAAM,QAAQ,kBAAkB,IAAI;AACpC,UAAM,QAAQ,OAAO;AAAA,MACnB,MACG,OAAO,CAAC,EAAE,IAAI,MAAM,EAAE,OAAO,KAAK,EAClC,IAAI,CAAC,EAAE,KAAK,MAAM,MAAM,CAAC,KAAK,KAAK,CAAC;AAAA,IACzC;AACA,WAAO,EAAE,GAAG,MAAM,GAAG,MAAM;AAAA,EAC7B;AAGA,SAAO,EAAE,GAAG,MAAM,GAAG,oBAAoB,IAAI,EAAE;AACjD;AAMO,SAAS,kBACd,OACY;AACZ,SAAO;AAAA,IACL,MAAM;AAAA,IACN,UAAU,MAAM,IAAI,CAAC,OAAO;AAAA,MAC1B,MAAM;AAAA,MACN,KAAK,EAAE;AAAA,MACP,OAAO,EAAE;AAAA,IACX,EAAE;AAAA,EACJ;AACF;","names":[]}
+{"version":3,"sources":["../../src/search/types.ts","../../src/search/filterExpr.ts"],"sourcesContent":["/**\n * FilterExpr -- lightweight boolean expression tree for search and filtering.\n *\n * Designed to start simple (a flat AND list of terms) and grow to support\n * full boolean queries (AND, OR, NOT, grouping) without breaking callers.\n *\n * The component always emits a FilterExpr. Callers that talk to a flat\n * server API today use flattenFilterExpr() to extract the terms. When the\n * server gains AST support, callers drop flattenFilterExpr and pass the\n * expression directly -- no component changes required.\n *\n * Extractable to @petrarca/sonnet-core: no app-specific imports.\n */\n\n/** A single field/value filter term -- the leaf node of a FilterExpr. */\nexport interface FilterTerm {\n  type: \"term\";\n  /** Schema property key -- used as the query param name sent to the server. */\n  key: string;\n  /** The filter value. */\n  value: string;\n}\n\n/** Conjunction: all children must match. */\nexport interface FilterAnd {\n  type: \"and\";\n  children: FilterExpr[];\n}\n\n/** Disjunction: at least one child must match. */\nexport interface FilterOr {\n  type: \"or\";\n  children: FilterExpr[];\n}\n\n/** Negation: child must not match. */\nexport interface FilterNot {\n  type: \"not\";\n  child: FilterExpr;\n}\n\n/**\n * Explicit grouping (parentheses). Semantically identical to its child --\n * used to preserve user intent when round-tripping the expression.\n */\nexport interface FilterGroup {\n  type: \"group\";\n  child: FilterExpr;\n}\n\n/** The full expression type. */\nexport type FilterExpr =\n  | FilterTerm\n  | FilterAnd\n  | FilterOr\n  | FilterNot\n  | FilterGroup;\n\n/** An empty expression -- no filters active. */\nexport const EMPTY_FILTER: FilterExpr = { type: \"and\", children: [] };\n","/**\n * Utilities for working with FilterExpr trees.\n *\n * Extractable to @petrarca/sonnet-core: no app-specific imports.\n */\n\nimport type { FilterExpr, FilterTerm } from \"./types\";\n\n/**\n * Return all term nodes from the expression as FilterTerm objects, depth-first.\n *\n * Ignores the boolean structure (AND / OR / NOT / GROUP).\n */\nexport function collectTerms(expr: FilterExpr): FilterTerm[] {\n  const out: FilterTerm[] = [];\n  collectTermNodes(expr, out);\n  return out;\n}\n\nfunction collectTermNodes(expr: FilterExpr, out: FilterTerm[]): void {\n  switch (expr.type) {\n    case \"term\":\n      out.push(expr);\n      break;\n    case \"and\":\n    case \"or\":\n      for (const child of expr.children) collectTermNodes(child, out);\n      break;\n    case \"not\":\n    case \"group\":\n      collectTermNodes(expr.child, out);\n      break;\n  }\n}\n\n/**\n * The value of the first term with `key`, or undefined -- for a facet used once.\n * Ignores the boolean structure, like collectTerms.\n */\nexport function termValue(expr: FilterExpr, key: string): string | undefined {\n  return collectTerms(expr).find((t) => t.key === key)?.value;\n}\n\n/**\n * The values of every term with `key`, in order -- for a repeatable facet.\n * Ignores the boolean structure, like collectTerms.\n */\nexport function termValues(expr: FilterExpr, key: string): string[] {\n  return collectTerms(expr)\n    .filter((t) => t.key === key)\n    .map((t) => t.value);\n}\n\n/**\n * Collect all term nodes from a FilterExpr tree as flat key/value pairs.\n *\n * Use this when talking to a server API that accepts only flat key/value\n * filter params. When the server gains AST support, pass the raw FilterExpr\n * instead and drop this call.\n *\n * @example\n * const terms = flattenFilterExpr(expr);\n * // [{ key: \"name\", value: \"acme\" }, { key: \"status\", value: \"active\" }]\n * const params = Object.fromEntries(terms.map(t => [t.key, t.value]));\n */\nexport function flattenFilterExpr(\n  expr: FilterExpr,\n): { key: string; value: string }[] {\n  return collectTerms(expr).map(({ key, value }) => ({ key, value }));\n}\n\n/**\n * Return true when the expression contains no term nodes.\n */\nexport function isEmptyFilterExpr(expr: FilterExpr): boolean {\n  return collectTerms(expr).length === 0;\n}\n\n/**\n * Check whether a FilterExpr is a flat AND of terms only (no OR/NOT/Group).\n * When true, the expression can be serialized as simple key=value params.\n * When false, it must be serialized as a `q=` expression string.\n */\nfunction isFlatAnd(expr: FilterExpr): boolean {\n  if (expr.type === \"term\") return true;\n  if (expr.type === \"and\") return expr.children.every((c) => c.type === \"term\");\n  return false;\n}\n\n/**\n * Serialize a FilterExpr to the server's q= expression syntax.\n *\n * Produces strings like `code ~ \"aspirin\" OR display ~ \"aspirin\"`.\n * All terms use the `~` (LIKE / substring) operator -- the FilterTerm\n * type carries no operator field; callers that need exact-match or other\n * operators should construct the q= string directly.\n */\nexport function serializeFilterExpr(expr: FilterExpr): string {\n  switch (expr.type) {\n    case \"term\": {\n      const escaped = expr.value.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"');\n      return `${expr.key} ~ \"${escaped}\"`;\n    }\n    case \"and\":\n      return expr.children.map((c) => serializeFilterExpr(c)).join(\" AND \");\n    case \"or\":\n      return expr.children.map((c) => serializeFilterExpr(c)).join(\" OR \");\n    case \"not\":\n      return `NOT (${serializeFilterExpr(expr.child)})`;\n    case \"group\":\n      return `(${serializeFilterExpr(expr.child)})`;\n  }\n}\n\n/**\n * Build a typed API params object from a FilterExpr and pagination state.\n *\n * Used by list and expansion pages to convert Zustand store state into\n * query params for the server. The base object carries pagination keys\n * (limit / offset); filter terms from the expression are merged in.\n *\n * When the expression is a flat AND of terms, each term becomes a flat\n * query param (backwards compatible with existing server endpoints).\n * When the expression contains OR/NOT/Group nodes, it is serialized\n * as a `q=` string using the server's query expression syntax.\n *\n * @example\n * const params = buildListParams<ValueSetListParams>(\n *   filterExpr,\n *   { limit: pagination.pageSize, offset: pagination.pageIndex * pagination.pageSize },\n * );\n */\nexport function buildListParams<T extends object>(\n  expr: FilterExpr,\n  base: T,\n): T {\n  if (isEmptyFilterExpr(expr)) return base;\n\n  // Flat AND of terms: serialize as individual key=value params.\n  if (isFlatAnd(expr)) {\n    const pairs = flattenFilterExpr(expr);\n    const extra = Object.fromEntries(\n      pairs\n        .filter(({ key }) => !(key in base))\n        .map(({ key, value }) => [key, value]),\n    );\n    return { ...base, ...extra } as T;\n  }\n\n  // Complex expression: serialize as q= string.\n  return { ...base, q: serializeFilterExpr(expr) } as T;\n}\n\n/**\n * Build a flat AND expression from an array of key/value pairs.\n * Convenience for constructing the initial state from existing filter params.\n */\nexport function termsToFilterExpr(\n  terms: { key: string; value: string }[],\n): FilterExpr {\n  return {\n    type: \"and\",\n    children: terms.map((t) => ({\n      type: \"term\",\n      key: t.key,\n      value: t.value,\n    })),\n  };\n}\n\n/**\n * A free text as a filter: the text in any of the fields -- one term per\n * field, OR-ed -- or, without fields, the server's own `search` term. Empty\n * text is no filter. What a search box sends for what is typed in it.\n */\nexport function textSearchExpr(text: string, fields?: string[]): FilterExpr {\n  const trimmed = text.trim();\n  if (!trimmed) return { type: \"and\", children: [] };\n  if (!fields?.length)\n    return {\n      type: \"and\",\n      children: [{ type: \"term\", key: \"search\", value: trimmed }],\n    };\n  const terms = fields.map(\n    (key): FilterExpr => ({ type: \"term\", key, value: trimmed }),\n  );\n  return {\n    type: \"and\",\n    children: terms.length === 1 ? terms : [{ type: \"or\", children: terms }],\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/terminology/index.d.ts

@@ -0,0 +1,161 @@
+import { Coding, CodingMatch } from '../schema/index.js';
+import React__default from 'react';
+
+/**
+ * The terminology service -- what a coded-value field asks of the application
+ * that serves its codes: search a list, look a code up, validate one. Transport-
+ * neutral: sonnet defines it, an application supplies it (a terminology server,
+ * lists of its own), and nothing in sonnet knows where codes come from. See
+ * docs/design/coded-values.md (workspace).
+ */
+
+/** Which list: a value set, or a code system -- identifiers the service resolves. */
+interface ListRef {
+    valueSet?: string;
+    system?: string;
+    version?: string;
+}
+/**
+ * A search hit: a coding, and where it sits -- its ancestors' labels, root
+ * first. A service may return properties of its own beside them (a concept's
+ * key): a field stores one with `x-ui-options.store`, a coding keeps them with
+ * `keep`.
+ */
+interface CodingHit extends Coding {
+    [property: string]: unknown;
+    path?: string[];
+}
+/** One page of a search: the hits, and how many there are in all. */
+interface SearchResult {
+    codings: CodingHit[];
+    total?: number;
+}
+/** What a validation says of a code: in the list -- and, when the service can say, known elsewhere. */
+interface ValidationResult {
+    inList: boolean;
+    /** Whether the code is known outside the list; none when the service cannot say. */
+    known?: boolean;
+    display?: string;
+    message?: string;
+}
+interface TerminologyService {
+    /** Codes of a list matching a text -- typeahead; no text: the list itself, paged. */
+    search(query: ListRef & {
+        text?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<SearchResult>;
+    /** One code's label and version -- to show a stored code. */
+    lookup(coding: LookupQuery): Promise<Coding | undefined>;
+    /** Whether a code is in a list -- to check a stored code. */
+    validate?(query: ValidateQuery): Promise<ValidationResult>;
+    /**
+     * Several lookups in one request, answered in their order; optional. The
+     * provider batches the lookups of a moment into it (FHIR: a batch Bundle).
+     */
+    lookupMany?(codings: LookupQuery[]): Promise<(Coding | undefined)[]>;
+    /** Several validations in one request, answered in their order; optional. */
+    validateMany?(queries: ValidateQuery[]): Promise<ValidationResult[]>;
+    /**
+     * A code in other lists, and how each relates to it -- FHIR `$translate`
+     * over a concept map; optional. A codeable concept's form asks it for its
+     * further lists once a code is picked in its first, and shows what it
+     * answers as suggestions. The mappings are the service's.
+     */
+    translate?(query: TranslateQuery): Promise<Translation[]>;
+}
+/** What a lookup asks: one code, by its system and version. */
+interface LookupQuery {
+    system: string;
+    code: string;
+    version?: string;
+}
+/** What a validation asks: whether a code is in a list. */
+type ValidateQuery = ListRef & {
+    code: string;
+};
+/** What a translation asks: one code, and the lists to find it in. */
+interface TranslateQuery {
+    coding: LookupQuery;
+    targets: ListRef[];
+}
+/** A code a translation found: its coding, and how it relates to the code asked -- the same, broader, narrower. */
+interface Translation {
+    coding: Coding;
+    match?: CodingMatch;
+}
+
+/**
+ * A terminology service over lists given inline -- as a code list given as
+ * data (genericode, a CSV) -- searched in memory, and over concept maps given
+ * inline, translated in memory. A small list needs no server; the playground
+ * and tests use it.
+ */
+
+/** A code list: its identifier (a value set's or a code system's), its codes. */
+interface CodeList {
+    /** The identifier a binding names: the value set, or the code system itself. */
+    id: string;
+    /** The code system of its codes, when the list is a value set of one system. */
+    system?: string;
+    /** Its codes: each a coding, its system the list's unless it names one; a path and properties of its own optional. */
+    codes: (Omit<Coding, "system"> & {
+        [property: string]: unknown;
+        system?: string;
+        path?: string[];
+    })[];
+}
+/** A concept map: the codes of one code system as codes of another, and how each relates (FHIR `ConceptMap`). */
+interface ConceptMap {
+    /** The code system mapped from. */
+    source: string;
+    /** The code system mapped to. */
+    target: string;
+    elements: {
+        code: string;
+        target: string;
+        match?: CodingMatch;
+    }[];
+}
+/** A terminology service over code lists -- and concept maps between them -- given inline. */
+declare function staticTerminology(lists: CodeList[], maps?: ConceptMap[]): TerminologyService;
+
+/**
+ * A terminology service that remembers and batches -- what TerminologyProvider
+ * puts in front of an application's service, so that a form of many coded
+ * fields does not flood it. Lookups and validations are kept, per list and
+ * code, for the session or a time; one already asked is not asked again while
+ * it is answered; those of a moment go as one request when the service offers
+ * the batch operations. Translations are kept the same way, per code and the
+ * lists asked. A failure is not kept: it is asked again next time. Searches
+ * pass through: their texts rarely repeat.
+ */
+
+/** How the provider remembers and batches. */
+interface TerminologyCacheOptions {
+    /** How long an answer counts, in milliseconds; default: the session. */
+    ttlMs?: number;
+    /** How long requests are collected into one batch, in milliseconds; default 10. */
+    batchWindowMs?: number;
+}
+/** The service, its lookups and validations remembered and batched. */
+declare function cachingTerminology(service: TerminologyService, options?: TerminologyCacheOptions): TerminologyService;
+
+/**
+ * Supply the terminology service to the coded-value fields below -- its
+ * lookups and validations remembered and batched (`cache`), so that a form of
+ * many coded fields does not flood it; `cache={false}` hands the service on as
+ * it is, for one that caches itself.
+ */
+declare function TerminologyProvider({ service, cache, children, }: {
+    service: TerminologyService;
+    /** How lookups and validations are remembered and batched; false: not at all. */
+    cache?: TerminologyCacheOptions | false;
+    children: React__default.ReactNode;
+}): React__default.ReactElement;
+
+/** The terminology service supplied; null when the application supplies none. */
+declare function useTerminology(): TerminologyService | null;
+
+export { TerminologyProvider, cachingTerminology, staticTerminology, useTerminology };
+export type { CodeList, CodingHit, ConceptMap, ListRef, LookupQuery, SearchResult, TerminologyCacheOptions, TerminologyService, TranslateQuery, Translation, ValidateQuery, ValidationResult };

package/dist/terminology/index.js

@@ -0,0 +1,178 @@
+// src/terminology/staticTerminology.ts
+function codingsOf(list) {
+  return list.codes.map((c) => ({
+    ...c,
+    system: c.system ?? list.system ?? list.id
+  }));
+}
+function matches(c, text) {
+  const t = text.toLowerCase();
+  return c.code.toLowerCase().includes(t) || (c.display ?? "").toLowerCase().includes(t);
+}
+function staticTerminology(lists, maps = []) {
+  const byRef = (ref) => lists.find((l) => l.id === (ref.valueSet ?? ref.system));
+  const all = lists.flatMap(codingsOf);
+  const lookupOne = ({ system, code }) => {
+    const found = all.find((c) => c.system === system && c.code === code);
+    if (!found) return void 0;
+    const { path: _path, ...coding } = found;
+    return coding;
+  };
+  const validateOne = ({ code, ...ref }) => {
+    const list = byRef(ref);
+    const inList = list ? codingsOf(list).find((c) => c.code === code) : void 0;
+    const known = all.find((c) => c.code === code);
+    return {
+      inList: !!inList,
+      known: !!known,
+      display: (inList ?? known)?.display
+    };
+  };
+  const translateTo = (coding, ref) => {
+    const list = byRef(ref);
+    const inList = list ? codingsOf(list) : [];
+    const system = ref.system ?? inList[0]?.system;
+    return maps.filter((m) => m.source === coding.system && m.target === system).flatMap((m) => m.elements.filter((e) => e.code === coding.code)).flatMap((e) => {
+      const found = inList.find((c) => c.code === e.target);
+      if (!found) return [];
+      const { path: _path, ...target } = found;
+      return [{ coding: target, ...e.match ? { match: e.match } : {} }];
+    });
+  };
+  return {
+    search({ text, limit = 50, offset = 0, ...ref }) {
+      const list = byRef(ref);
+      const codings = (list ? codingsOf(list) : []).filter(
+        (c) => !text || matches(c, text)
+      );
+      return Promise.resolve({
+        codings: codings.slice(offset, offset + limit),
+        total: codings.length
+      });
+    },
+    lookup: (q) => Promise.resolve(lookupOne(q)),
+    validate: (q) => Promise.resolve(validateOne(q)),
+    // The batch operations: what a service answering several in one request offers.
+    lookupMany: (qs) => Promise.resolve(qs.map(lookupOne)),
+    validateMany: (qs) => Promise.resolve(qs.map(validateOne)),
+    translate: ({ coding, targets }) => Promise.resolve(targets.flatMap((t) => translateTo(coding, t)))
+  };
+}
+
+// src/terminology/cachingTerminology.ts
+function batcher(windowMs, one, many) {
+  if (!many) return one;
+  let pending = [];
+  let timer;
+  const flush = () => {
+    const batch = pending;
+    pending = [];
+    timer = void 0;
+    many(batch.map((b) => b.q)).then(
+      (answers) => {
+        if (answers.length !== batch.length) {
+          const e = new Error(
+            `a batch of ${batch.length} was answered with ${answers.length}`
+          );
+          return batch.forEach((b) => b.reject(e));
+        }
+        batch.forEach((b, i) => b.resolve(answers[i]));
+      },
+      (e) => batch.forEach((b) => b.reject(e))
+    );
+  };
+  return (q) => new Promise((resolve, reject) => {
+    pending.push({ q, resolve, reject });
+    timer ??= setTimeout(flush, windowMs);
+  });
+}
+function remembering(key, ask, ttlMs) {
+  const kept = /* @__PURE__ */ new Map();
+  return (q) => {
+    const k = key(q);
+    const hit = kept.get(k);
+    if (hit && (ttlMs === void 0 || Date.now() - hit.at < ttlMs))
+      return hit.answer;
+    const answer = ask(q);
+    kept.set(k, { answer, at: Date.now() });
+    answer.catch(() => kept.delete(k));
+    return answer;
+  };
+}
+var lookupKey = (q) => [q.system, q.version ?? "", q.code].join("|");
+var validateKey = (q) => [q.valueSet ?? "", q.system ?? "", q.version ?? "", q.code].join("|");
+var listKey = (l) => [l.valueSet ?? "", l.system ?? "", l.version ?? ""].join("|");
+var translateKey = (q) => [lookupKey(q.coding), ...q.targets.map(listKey)].join("#");
+function cachingTerminology(service, options = {}) {
+  const windowMs = options.batchWindowMs ?? 10;
+  const lookup = remembering(
+    lookupKey,
+    batcher(
+      windowMs,
+      (q) => service.lookup(q),
+      service.lookupMany && ((qs) => service.lookupMany(qs))
+    ),
+    options.ttlMs
+  );
+  const validateOne = service.validate;
+  const validate = validateOne && remembering(
+    validateKey,
+    batcher(
+      windowMs,
+      (q) => validateOne.call(service, q),
+      service.validateMany && ((qs) => service.validateMany(qs))
+    ),
+    options.ttlMs
+  );
+  const translateOne = service.translate;
+  const translate = translateOne && remembering(
+    translateKey,
+    (q) => translateOne.call(service, q),
+    options.ttlMs
+  );
+  return {
+    search: (query) => service.search(query),
+    lookup,
+    ...validate ? { validate } : {},
+    ...translate ? { translate } : {}
+  };
+}
+
+// src/terminology/TerminologyProvider.tsx
+import { useMemo } from "react";
+
+// src/terminology/terminologyContext.ts
+import { createContext } from "react";
+var TerminologyContext = createContext(
+  null
+);
+
+// src/terminology/TerminologyProvider.tsx
+import { jsx } from "react/jsx-runtime";
+function TerminologyProvider({
+  service,
+  cache,
+  children
+}) {
+  const ttlMs = cache ? cache.ttlMs : void 0;
+  const batchWindowMs = cache ? cache.batchWindowMs : void 0;
+  const off = cache === false;
+  const value = useMemo(
+    () => off ? service : cachingTerminology(service, { ttlMs, batchWindowMs }),
+    [service, off, ttlMs, batchWindowMs]
+  );
+  return /* @__PURE__ */ jsx(TerminologyContext.Provider, { value, children });
+}
+
+// src/terminology/useTerminology.ts
+import { useContext } from "react";
+function useTerminology() {
+  return useContext(TerminologyContext);
+}
+export {
+  TerminologyProvider,
+  cachingTerminology,
+  staticTerminology,
+  useTerminology
+};
+//# sourceMappingURL=index.js.map

package/dist/terminology/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/terminology/staticTerminology.ts","../../src/terminology/cachingTerminology.ts","../../src/terminology/TerminologyProvider.tsx","../../src/terminology/terminologyContext.ts","../../src/terminology/useTerminology.ts"],"sourcesContent":["/**\n * A terminology service over lists given inline -- as a code list given as\n * data (genericode, a CSV) -- searched in memory, and over concept maps given\n * inline, translated in memory. A small list needs no server; the playground\n * and tests use it.\n */\n\nimport type { Coding, CodingMatch } from \"../schema/coreTypes\";\nimport type {\n  CodingHit,\n  ListRef,\n  LookupQuery,\n  TerminologyService,\n  TranslateQuery,\n  Translation,\n  ValidateQuery,\n  ValidationResult,\n} from \"./types\";\n\n/** A code list: its identifier (a value set's or a code system's), its codes. */\nexport interface CodeList {\n  /** The identifier a binding names: the value set, or the code system itself. */\n  id: string;\n  /** The code system of its codes, when the list is a value set of one system. */\n  system?: string;\n  /** Its codes: each a coding, its system the list's unless it names one; a path and properties of its own optional. */\n  codes: (Omit<Coding, \"system\"> & {\n    [property: string]: unknown;\n    system?: string;\n    path?: string[];\n  })[];\n}\n\n/** A concept map: the codes of one code system as codes of another, and how each relates (FHIR `ConceptMap`). */\nexport interface ConceptMap {\n  /** The code system mapped from. */\n  source: string;\n  /** The code system mapped to. */\n  target: string;\n  elements: { code: string; target: string; match?: CodingMatch }[];\n}\n\n// A list's codes as codings: each its own system, or the list's.\nfunction codingsOf(list: CodeList): CodingHit[] {\n  return list.codes.map((c) => ({\n    ...c,\n    system: c.system ?? list.system ?? list.id,\n  }));\n}\n\n// Whether a coding matches a search text: its label or its code.\nfunction matches(c: Coding, text: string): boolean {\n  const t = text.toLowerCase();\n  return (\n    c.code.toLowerCase().includes(t) ||\n    (c.display ?? \"\").toLowerCase().includes(t)\n  );\n}\n\n/** A terminology service over code lists -- and concept maps between them -- given inline. */\nexport function staticTerminology(\n  lists: CodeList[],\n  maps: ConceptMap[] = [],\n): TerminologyService {\n  const byRef = (ref: ListRef) =>\n    lists.find((l) => l.id === (ref.valueSet ?? ref.system));\n  const all = lists.flatMap(codingsOf);\n\n  // One code's label, without its path.\n  const lookupOne = ({ system, code }: LookupQuery): Coding | undefined => {\n    const found = all.find((c) => c.system === system && c.code === code);\n    if (!found) return undefined;\n    const { path: _path, ...coding } = found;\n    return coding;\n  };\n\n  // Whether a code is in a list, known elsewhere, and its label.\n  const validateOne = ({ code, ...ref }: ValidateQuery): ValidationResult => {\n    const list = byRef(ref);\n    const inList = list\n      ? codingsOf(list).find((c) => c.code === code)\n      : undefined;\n    const known = all.find((c) => c.code === code);\n    return {\n      inList: !!inList,\n      known: !!known,\n      display: (inList ?? known)?.display,\n    };\n  };\n\n  // A code in one target list: what the maps from its system say, kept to the list's codes.\n  const translateTo = (coding: LookupQuery, ref: ListRef): Translation[] => {\n    const list = byRef(ref);\n    const inList = list ? codingsOf(list) : [];\n    const system = ref.system ?? inList[0]?.system;\n    return maps\n      .filter((m) => m.source === coding.system && m.target === system)\n      .flatMap((m) => m.elements.filter((e) => e.code === coding.code))\n      .flatMap((e) => {\n        const found = inList.find((c) => c.code === e.target);\n        if (!found) return [];\n        const { path: _path, ...target } = found;\n        return [{ coding: target, ...(e.match ? { match: e.match } : {}) }];\n      });\n  };\n\n  return {\n    search({ text, limit = 50, offset = 0, ...ref }) {\n      const list = byRef(ref);\n      const codings = (list ? codingsOf(list) : []).filter(\n        (c) => !text || matches(c, text),\n      );\n      return Promise.resolve({\n        codings: codings.slice(offset, offset + limit),\n        total: codings.length,\n      });\n    },\n    lookup: (q) => Promise.resolve(lookupOne(q)),\n    validate: (q) => Promise.resolve(validateOne(q)),\n    // The batch operations: what a service answering several in one request offers.\n    lookupMany: (qs) => Promise.resolve(qs.map(lookupOne)),\n    validateMany: (qs) => Promise.resolve(qs.map(validateOne)),\n    translate: ({ coding, targets }: TranslateQuery) =>\n      Promise.resolve(targets.flatMap((t) => translateTo(coding, t))),\n  };\n}\n","/**\n * A terminology service that remembers and batches -- what TerminologyProvider\n * puts in front of an application's service, so that a form of many coded\n * fields does not flood it. Lookups and validations are kept, per list and\n * code, for the session or a time; one already asked is not asked again while\n * it is answered; those of a moment go as one request when the service offers\n * the batch operations. Translations are kept the same way, per code and the\n * lists asked. A failure is not kept: it is asked again next time. Searches\n * pass through: their texts rarely repeat.\n */\n\nimport type { Coding } from \"../schema/coreTypes\";\nimport type {\n  ListRef,\n  LookupQuery,\n  TerminologyService,\n  TranslateQuery,\n  Translation,\n  ValidateQuery,\n  ValidationResult,\n} from \"./types\";\n\n/** How the provider remembers and batches. */\nexport interface TerminologyCacheOptions {\n  /** How long an answer counts, in milliseconds; default: the session. */\n  ttlMs?: number;\n  /** How long requests are collected into one batch, in milliseconds; default 10. */\n  batchWindowMs?: number;\n}\n\ninterface Kept<R> {\n  answer: Promise<R>;\n  at: number;\n}\n\n// Requests of a moment, sent together: through `many` when the service has it, else one by one.\nfunction batcher<Q, R>(\n  windowMs: number,\n  one: (q: Q) => Promise<R>,\n  many: ((qs: Q[]) => Promise<R[]>) | undefined,\n): (q: Q) => Promise<R> {\n  if (!many) return one;\n  let pending: {\n    q: Q;\n    resolve: (r: R) => void;\n    reject: (e: unknown) => void;\n  }[] = [];\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const flush = () => {\n    const batch = pending;\n    pending = [];\n    timer = undefined;\n    many(batch.map((b) => b.q)).then(\n      (answers) => {\n        // One answer per request, in their order: any other count is no answer to trust.\n        if (answers.length !== batch.length) {\n          const e = new Error(\n            `a batch of ${batch.length} was answered with ${answers.length}`,\n          );\n          return batch.forEach((b) => b.reject(e));\n        }\n        batch.forEach((b, i) => b.resolve(answers[i]));\n      },\n      (e) => batch.forEach((b) => b.reject(e)),\n    );\n  };\n  return (q) =>\n    new Promise<R>((resolve, reject) => {\n      pending.push({ q, resolve, reject });\n      timer ??= setTimeout(flush, windowMs);\n    });\n}\n\n// Answers kept by key, for a time; an answer asked for while it is answered is shared.\nfunction remembering<Q, R>(\n  key: (q: Q) => string,\n  ask: (q: Q) => Promise<R>,\n  ttlMs: number | undefined,\n): (q: Q) => Promise<R> {\n  const kept = new Map<string, Kept<R>>();\n  return (q) => {\n    const k = key(q);\n    const hit = kept.get(k);\n    if (hit && (ttlMs === undefined || Date.now() - hit.at < ttlMs))\n      return hit.answer;\n    const answer = ask(q);\n    kept.set(k, { answer, at: Date.now() });\n    // A failure is not kept.\n    answer.catch(() => kept.delete(k));\n    return answer;\n  };\n}\n\nconst lookupKey = (q: LookupQuery) =>\n  [q.system, q.version ?? \"\", q.code].join(\"|\");\nconst validateKey = (q: ValidateQuery) =>\n  [q.valueSet ?? \"\", q.system ?? \"\", q.version ?? \"\", q.code].join(\"|\");\nconst listKey = (l: ListRef) =>\n  [l.valueSet ?? \"\", l.system ?? \"\", l.version ?? \"\"].join(\"|\");\nconst translateKey = (q: TranslateQuery) =>\n  [lookupKey(q.coding), ...q.targets.map(listKey)].join(\"#\");\n\n/** The service, its lookups and validations remembered and batched. */\nexport function cachingTerminology(\n  service: TerminologyService,\n  options: TerminologyCacheOptions = {},\n): TerminologyService {\n  const windowMs = options.batchWindowMs ?? 10;\n  const lookup = remembering<LookupQuery, Coding | undefined>(\n    lookupKey,\n    batcher(\n      windowMs,\n      (q) => service.lookup(q),\n      service.lookupMany && ((qs) => service.lookupMany!(qs)),\n    ),\n    options.ttlMs,\n  );\n  const validateOne = service.validate;\n  const validate =\n    validateOne &&\n    remembering<ValidateQuery, ValidationResult>(\n      validateKey,\n      batcher(\n        windowMs,\n        (q) => validateOne.call(service, q),\n        service.validateMany && ((qs) => service.validateMany!(qs)),\n      ),\n      options.ttlMs,\n    );\n  const translateOne = service.translate;\n  const translate =\n    translateOne &&\n    remembering<TranslateQuery, Translation[]>(\n      translateKey,\n      (q) => translateOne.call(service, q),\n      options.ttlMs,\n    );\n  return {\n    search: (query) => service.search(query),\n    lookup,\n    ...(validate ? { validate } : {}),\n    ...(translate ? { translate } : {}),\n  };\n}\n","import React, { useMemo } from \"react\";\nimport {\n  cachingTerminology,\n  type TerminologyCacheOptions,\n} from \"./cachingTerminology\";\nimport { TerminologyContext } from \"./terminologyContext\";\nimport type { TerminologyService } from \"./types\";\n\n/**\n * Supply the terminology service to the coded-value fields below -- its\n * lookups and validations remembered and batched (`cache`), so that a form of\n * many coded fields does not flood it; `cache={false}` hands the service on as\n * it is, for one that caches itself.\n */\nexport function TerminologyProvider({\n  service,\n  cache,\n  children,\n}: {\n  service: TerminologyService;\n  /** How lookups and validations are remembered and batched; false: not at all. */\n  cache?: TerminologyCacheOptions | false;\n  children: React.ReactNode;\n}): React.ReactElement {\n  const ttlMs = cache ? cache.ttlMs : undefined;\n  const batchWindowMs = cache ? cache.batchWindowMs : undefined;\n  const off = cache === false;\n  // One cache per service and settings: the options' identity does not matter.\n  const value = useMemo(\n    () =>\n      off ? service : cachingTerminology(service, { ttlMs, batchWindowMs }),\n    [service, off, ttlMs, batchWindowMs],\n  );\n  return (\n    <TerminologyContext.Provider value={value}>\n      {children}\n    </TerminologyContext.Provider>\n  );\n}\n","/**\n * The terminology service an application supplies -- by context, as the entity\n * fetcher is. Without one, a coded-value field says so and shows stored codes\n * with their stored label: nothing is lost.\n */\n\nimport { createContext } from \"react\";\nimport type { TerminologyService } from \"./types\";\n\nexport const TerminologyContext = createContext<TerminologyService | null>(\n  null,\n);\n","import { useContext } from \"react\";\nimport { TerminologyContext } from \"./terminologyContext\";\nimport type { TerminologyService } from \"./types\";\n\n/** The terminology service supplied; null when the application supplies none. */\nexport function useTerminology(): TerminologyService | null {\n  return useContext(TerminologyContext);\n}\n"],"mappings":"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","names":[]}

package/dist/{types-DJ4hb97y.d.ts → types-BiFVnfqr.d.ts}

@@ -73,4 +73,4 @@ interface GraphqlFetcherConfig {
  */
 type EntityFetcherFactory = (options: RestFetcherConfig | GraphqlFetcherConfig) => EntityOptionFetcher;
 
-export type { EntityOptionFetcher as E, GraphqlFetcherConfig as G, RestFetcherConfig as R, EntityOption as a, EntityFetcherFactory as b, EntityFetchParams as c };
+export type { EntityFetcherFactory as E, GraphqlFetcherConfig as G, RestFetcherConfig as R, EntityOption as a, EntityOptionFetcher as b, EntityFetchParams as c };