fhirpath-ts 0.1.0 → 0.2.1

package/src/r4/index.ts

@@ -1,8 +1,8 @@
 import { FhirPathEngine } from '../api/engine.ts'
 import type { ElementInfo, ModelProvider } from '../model/provider.ts'
-import { R4_RESOURCES } from './generated/resources-data.ts'
-import { R4_DATA_TYPES } from './generated/types-data.ts'
-import type { GeneratedElement, GeneratedType } from './model-data.ts'
+import { R4_RESOURCES_COMPACT } from './generated/resources-data.ts'
+import { R4_DATA_TYPES_COMPACT } from './generated/types-data.ts'
+import { CompactTypeTable, type GeneratedElement, type GeneratedType } from './model-data.ts'
 
 // One canonical FHIR-primitive → System map lives in values/typed-value.ts;
 // re-exported here because the model subpath is where consumers look for it.
@@ -12,8 +12,11 @@ export type { GeneratedElement, GeneratedType } from './model-data.ts'
 const NAMESPACE = 'FHIR'
 const PREFIX = `${NAMESPACE}.`
 
+const RESOURCES = new CompactTypeTable(R4_RESOURCES_COMPACT)
+const DATA_TYPES = new CompactTypeTable(R4_DATA_TYPES_COMPACT)
+
 function lookupType(name: string): GeneratedType | undefined {
-  return R4_RESOURCES[name] ?? R4_DATA_TYPES[name]
+  return RESOURCES.get(name) ?? DATA_TYPES.get(name)
 }
 
 function localName(canonical: string): string {
@@ -85,7 +88,10 @@ export const r4Model: ModelProvider = {
       }
       current = definition.b
     }
-    return names
+    // The tables carry each inherited element only on the type that declares
+    // it, so the walk yields own elements before inherited ones; sorting gives
+    // callers one stable order independent of where an element is declared.
+    return names.sort()
   },
 
   isSubtypeOf(type: string, base: string): boolean {

package/src/r4/model-data.ts

@@ -15,3 +15,130 @@ export interface GeneratedType {
   b?: string
   e: Record<string, GeneratedElement>
 }
+
+/**
+ * The generated tables ship as one compact string instead of an object literal:
+ * the string is smaller to download and cheaper to decode than a large literal
+ * is to parse, and `CompactTypeTable` decodes one type at a time so only the
+ * types an application touches are ever materialized.
+ *
+ * Format, one line per type:
+ *
+ *     Name|Base|element:type1,type2*^<Target1,Target2;element2:type
+ *
+ * `*` marks a collection (`a: 1`), `^` a choice element (`c: 1`), and `<`
+ * starts the Reference target list (`r`). An empty Base segment means the type
+ * has no base. Elements identical to the nearest ancestor's entry are omitted
+ * by the generator; lookups walk the base chain (see index.ts).
+ */
+const RESERVED_IN_COMPACT = /[|;:,*^<\n\\`$]/
+
+function assertCompactSafe(name: string): string {
+  if (RESERVED_IN_COMPACT.test(name)) {
+    throw new Error(`name contains a character reserved by the compact model encoding: ${name}`)
+  }
+  return name
+}
+
+/** Encodes a generated table into the compact string form (generator-side; see the format above). */
+export function encodeCompactTypes(types: Record<string, GeneratedType>): string {
+  const lines: string[] = []
+  for (const [name, type] of Object.entries(types)) {
+    const elements = Object.entries(type.e).map(([element, info]) => {
+      let entry = `${assertCompactSafe(element)}:${info.t.map(assertCompactSafe).join(',')}`
+      if (info.a === 1) {
+        entry += '*'
+      }
+      if (info.c === 1) {
+        entry += '^'
+      }
+      if (info.r !== undefined) {
+        entry += `<${info.r.map(assertCompactSafe).join(',')}`
+      }
+      return entry
+    })
+    lines.push(`${assertCompactSafe(name)}|${assertCompactSafe(type.b ?? '')}|${elements.join(';')}`)
+  }
+  return lines.join('\n')
+}
+
+/** Decodes the segment after the second `|` of a line. */
+function decodeTypeLine(line: string): GeneratedType {
+  const baseStart = line.indexOf('|') + 1
+  const baseEnd = line.indexOf('|', baseStart)
+  const base = line.slice(baseStart, baseEnd)
+  const e: Record<string, GeneratedElement> = {}
+  const body = line.slice(baseEnd + 1)
+  if (body !== '') {
+    for (const entry of body.split(';')) {
+      const colon = entry.indexOf(':')
+      const name = entry.slice(0, colon)
+      let rest = entry.slice(colon + 1)
+      const element: GeneratedElement = { t: [] }
+      const targetsStart = rest.indexOf('<')
+      if (targetsStart >= 0) {
+        element.r = rest.slice(targetsStart + 1).split(',')
+        rest = rest.slice(0, targetsStart)
+      }
+      if (rest.endsWith('^')) {
+        element.c = 1
+        rest = rest.slice(0, -1)
+      }
+      if (rest.endsWith('*')) {
+        element.a = 1
+        rest = rest.slice(0, -1)
+      }
+      element.t = rest.split(',')
+      e[name] = element
+    }
+  }
+  return base === '' ? { e } : { b: base, e }
+}
+
+/** Eagerly decodes a whole table; for build scripts, not the runtime path. */
+export function decodeCompactTypes(encoded: string): Record<string, GeneratedType> {
+  const types: Record<string, GeneratedType> = {}
+  for (const line of encoded.split('\n')) {
+    types[line.slice(0, line.indexOf('|'))] = decodeTypeLine(line)
+  }
+  return types
+}
+
+/**
+ * Lazy view over a compact-encoded table. The line index is built on first
+ * lookup and each type is decoded once, on demand, so importing the model costs
+ * almost nothing until an expression actually navigates it.
+ */
+export class CompactTypeTable {
+  private readonly encoded: string
+  private index: Map<string, string> | undefined
+  private readonly decoded = new Map<string, GeneratedType>()
+
+  constructor(encoded: string) {
+    this.encoded = encoded
+  }
+
+  get(name: string): GeneratedType | undefined {
+    const cached = this.decoded.get(name)
+    if (cached !== undefined) {
+      return cached
+    }
+    const line = this.lines().get(name)
+    if (line === undefined) {
+      return undefined
+    }
+    const type = decodeTypeLine(line)
+    this.decoded.set(name, type)
+    return type
+  }
+
+  private lines(): Map<string, string> {
+    if (this.index === undefined) {
+      this.index = new Map()
+      for (const line of this.encoded.split('\n')) {
+        this.index.set(line.slice(0, line.indexOf('|')), line)
+      }
+    }
+    return this.index
+  }
+}

package/src/typed/context-maps.ts

@@ -0,0 +1,41 @@
+/** An empty host context that contributes no known keys. */
+export type EmptyContextMap = Record<never, never>
+
+/** Preserve host values for best-effort type inference without exposing them as declarations. */
+export type HostValueDeclarations<Values> =
+  Values extends Readonly<Record<PropertyKey, unknown>>
+    ? { readonly [Name in keyof Values]: { readonly __value: Values[Name] } }
+    : EmptyContextMap
+
+/** Environment names are stored without the optional leading `%`. */
+export type BareContextName<Name extends PropertyKey> = Name extends string
+  ? Name extends `%${infer Bare}`
+    ? Bare
+    : Name
+  : Name
+
+/** Normalize both accepted environment-key spellings into one type-level map. */
+export type NormalizeContextMap<Map> =
+  Map extends Readonly<Record<PropertyKey, unknown>>
+    ? { readonly [Name in keyof Map as BareContextName<Name>]: Map[Name] }
+    : EmptyContextMap
+
+/** Merge normalized maps by name, with the overlay taking precedence. */
+export type MergeContextMaps<Base, Overlay> = Omit<NormalizeContextMap<Base>, keyof NormalizeContextMap<Overlay>> &
+  NormalizeContextMap<Overlay>
+
+/** Infer undeclared host values while letting explicit declarations replace them. */
+export type InferredHostValueDeclarations<Values, Declarations> =
+  keyof NormalizeContextMap<Values> extends keyof NormalizeContextMap<Declarations>
+    ? NormalizeContextMap<Declarations>
+    : MergeContextMaps<HostValueDeclarations<Values>, Declarations>
+
+/** Read an optional context field without distributing undefined into its map. */
+export type ContextProperty<Context, Name extends PropertyKey> = Name extends keyof Context
+  ? Exclude<Context[Name], undefined>
+  : EmptyContextMap
+
+/** Look up one normalized name, returning never when it is undeclared. */
+export type LookupContextMap<Map, Name extends string> = Name extends keyof NormalizeContextMap<Map>
+  ? NormalizeContextMap<Map>[Name]
+  : never