@owlmeans/state 0.1.18-rc.2 → 0.1.18-rc.21

package/src/types.ts

@@ -1,49 +1,122 @@
-import type { ListCriteria, Resource, ResourceRecord } from '@owlmeans/resource'
+import type {
+  Criteria, FirstOptions, PubSubResource, Resource, ResourceRecord
+} from '@owlmeans/resource'
 
-export interface StateResource<T extends ResourceRecord> extends Resource<T> {
+/**
+ * How a state resource is keyed and what it shows before anything is loaded.
+ *
+ * Everything here is optional: an unconfigured resource keys records by `id`, holds as many of
+ * them as it is given, and shows an empty object until a record arrives.
+ */
+export interface StateConfig<T extends ResourceRecord> {
+  /** The field records are keyed by. Defaults to `id`. */
+  id?: keyof T & string
   /**
-   * @returns unsubscribe function
+   * The resource holds exactly ONE record, which therefore needs no id — the current user, the
+   * active session, a wizard being filled in. It is what makes `watch(undefined, ...)` (and so
+   * `useStoreModel()` with no id) answerable: elsewhere there is no "the record" to address.
    */
-  subscribe: (params: StateSubscriptionOption<T>) => [() => void, StateModel<T>[]]
-  listen: (listener: StateListener<T>) => () => void
-  erase: () => Promise<void>
+  single?: boolean
+  /**
+   * What {@link StateModel.record} shows while the model is empty. A screen that binds to a
+   * record before it has arrived reads the default instead of guarding every field — and the
+   * store still holds nothing, so nothing renders it as a row.
+   */
+  default?: () => T
 }
 
-export interface StateSubscriptionOption<T extends ResourceRecord> {
-  id?: string | string[]
-  _systemId?: string
-  query?: ListCriteria
-  default?: Partial<T>
-  listener: StateListener<T>
+/** One change to the store, as its subscribers see it. */
+export interface StateEvent<T extends ResourceRecord> {
+  type: 'set' | 'remove'
+  records: T[]
 }
 
-export interface StateListener<T extends ResourceRecord> {
-  (record: StateModel<T>[], systemId?: string): void | Promise<void>
-}
+/**
+ * The framework's client store: a `Resource` like any other, registered ON the context — which is
+ * what separates it from a store held beside the app, since a screen, a service and a guard all
+ * reach the same records through the same container.
+ *
+ * Reads and writes are the resource vocabulary; `watch` and `query` are the live half, and they
+ * are synchronous on purpose — a React subscriber has to have its value before it renders.
+ */
+export interface StateResource<T extends ResourceRecord> extends Resource<T>, PubSubResource<StateEvent<T>> {
+  readonly config: StateConfig<T>
 
-export interface StateModel<T extends ResourceRecord> {
-  record: T,
+  /**
+   * Make the store agree with an authoritative list: every record given is written, and every
+   * record the list does not name is dropped. That is the shape of "the server just told us what
+   * exists" — saving each record one by one leaves the ones deleted elsewhere behind.
+   */
+  replace(records: T[]): Promise<void>
 
-  commit: (force?: boolean) => void
+  /** Drop every record. */
+  clear(): Promise<void>
 
-  update: (data?: Partial<T>) => void
+  /**
+   * Follow one record. The listener is called with the current model straight away — before
+   * `watch` returns — and again on every change to that record, including its removal.
+   *
+   * `undefined` addresses the one record of a `single` resource; on any other it throws, since
+   * there is nothing for it to mean.
+   *
+   * An absent id on a listed resource watches nothing and reports an empty model — a screen
+   * binds before the record supplying the id exists, and that is a loading state, not an error.
+   * @returns unsubscribe
+   */
+  watch(id: string | undefined, listener: (model: StateModel<T>) => void): () => void
 
-  clear: () => void
+  /**
+   * Follow a live QUERY. The listener is called with the matching models straight away and again
+   * whenever a write changes the answer, so a list screen never recomputes ids and never
+   * re-subscribes to keep up. `undefined` matches every record.
+   *
+   * A query subscription creates nothing: an empty store yields an empty list.
+   *
+   * @returns unsubscribe
+   */
+  query(
+    where: Criteria<T> | undefined,
+    listener: (models: StateModel<T>[]) => void,
+    opts?: FirstOptions<T>
+  ): () => void
 }
 
-export interface StateResourceAppend {
-  getStateResource: <T extends ResourceRecord>(alias?: string) => StateResource<T>
+/**
+ * One record, as something bound to it can hold: what it currently says, and how to change it.
+ *
+ * `record` is a snapshot — assigning into it changes nothing anyone can see. `update` is how a
+ * change reaches the store and every other subscriber.
+ */
+export interface StateModel<T extends ResourceRecord> {
+  readonly id: string | undefined
+  /**
+   * Nothing is loaded yet: the store holds no record under this model's key. This — not a
+   * sentinel id, and not a placeholder record — is what "not there" looks like, so a subscription
+   * to an unknown id leaves the store exactly as empty as it found it.
+   */
+  readonly empty: boolean
+  /** The record, or the configured `default` while {@link StateModel.empty} is true. */
+  readonly record: Readonly<T>
+  /** Merge and write in one step. */
+  update(patch: Partial<T>): Promise<T>
+  /** Write what {@link StateModel.record} currently holds — including a default not yet stored. */
+  commit(): Promise<T>
+  clear(): Promise<void>
 }
 
-export interface UseStoreHelper {
-  <T extends ResourceRecord>(id?: string | UseStoreHelperOptions<T>, opts?: string | boolean | UseStoreHelperOptions<T>): StateModel<T>
-}
+/**
+ * A state alias that remembers the record type it addresses, so `getStateResource(TASKS)` is
+ * typed without repeating `<Task>` at every call site. Built by {@link stateAlias}; it is a plain
+ * string at runtime, so it works anywhere an alias is expected.
+ */
+export type StateAlias<T extends ResourceRecord> = string & { readonly _state?: T }
 
-export interface UseStoreListHelper {
-  <T extends ResourceRecord>(id?: string | string[] | UseStoreHelperOptions<T>, opts?: string | boolean | UseStoreHelperOptions<T>): StateModel<T>[]
+export interface GetStateResource {
+  <T extends ResourceRecord>(alias: StateAlias<T>): StateResource<T>
+  <T extends ResourceRecord = ResourceRecord>(alias?: string): StateResource<T>
 }
 
-export interface UseStoreHelperOptions<T extends ResourceRecord> extends Omit<StateSubscriptionOption<T>, "listener"> {
-  listen?: boolean
-  resource?: string
+export interface StateResourceAppend {
+  /** The state resource under `alias`, or the first one appended to the context. */
+  getStateResource: GetStateResource
 }

package/src/utils/model.ts

@@ -1,40 +1,60 @@
 import type { ResourceRecord } from '@owlmeans/resource'
-import { MisshapedRecord } from '@owlmeans/resource'
-import type { StateModel, StateResource } from '../types.js'
+import type { StateModel } from '../types.js'
 
+/**
+ * What a model needs from the resource that made it: which record it stands for, and the two
+ * writes it can perform. The key stays on the resource side, so a model bound to the one record
+ * of a `single` resource works the same as one bound to an id.
+ */
+export interface StateModelBinding<T extends ResourceRecord> {
+  id: string | undefined
+  /** The stored record, or `undefined` when the store holds none — an EMPTY model. */
+  record: T | undefined
+  default?: () => T
+  write: (record: T) => Promise<T>
+  drop: () => Promise<void>
+}
+
+/**
+ * Wrap one record — or its absence — as something a screen can bind to.
+ *
+ * The working copy is replaced rather than mutated on every write, so the record a caller is
+ * holding never changes underneath it and two models of the same record stay comparable by
+ * reference.
+ */
 export const createStateModel = <T extends ResourceRecord>(
-  record: T, resource: StateResource<T>
+  binding: StateModelBinding<T>
 ): StateModel<T> => {
-  let before: T = record
+  /** What an empty model shows: the configured default, or nothing at all. */
+  const blank = (): T => binding.default?.() ?? {} as T
+
+  let working: T = binding.record ?? blank()
+  let stored = binding.record != null
+
   const model: StateModel<T> = {
-    record: { ...record },
-
-    commit: force => {
-      if (force !== true) {
-        if (!Object.entries(before).reduce(
-          (changed, [key, value]) => changed || model.record[key as keyof T] !== value, false
-        ) && !Object.entries(model.record).reduce(
-          (changed, [key, value]) => changed || before[key as keyof T] !== value, false
-        )) {
-          return
-        }
-      }
-      if (record.id == null) {
-        throw new MisshapedRecord('id')
-      }
-      before = model.record
-      void resource.load(record.id).then(exists => {
-        exists != null && resource.update(model.record)
-      })
+    get id() { return binding.id },
+
+    get empty() { return !stored },
+
+    get record() { return working },
+
+    update: async patch => {
+      working = { ...working, ...patch } as T
+
+      return model.commit()
     },
 
-    update: data => {
-      Object.assign(model.record, data)
-      model.commit()
+    commit: async () => {
+      working = await binding.write(working)
+      stored = true
+
+      return working
     },
 
-    clear: () => {
-      void resource.delete(record)
+    clear: async () => {
+      await binding.drop()
+      stored = false
+      working = blank()
     }
   }
 

package/tests/resource.spec.ts

@@ -0,0 +1,419 @@
+import { describe, expect, test } from 'bun:test'
+import { createStateResource, StateConfigError } from '@owlmeans/state'
+import type { StateEvent, StateModel } from '@owlmeans/state'
+import type { ResourceRecord } from '@owlmeans/resource'
+
+interface Task extends ResourceRecord {
+  title?: string
+  status?: string
+  points?: number
+}
+
+interface Session extends ResourceRecord {
+  token?: string
+  user?: string
+}
+
+interface Doc extends ResourceRecord {
+  key?: string
+  body?: string
+}
+
+const seeded = async () => {
+  const resource = createStateResource<Task>('tasks')
+  await resource.create({ id: 'a', title: 'Alpha', status: 'open', points: 3 })
+  await resource.create({ id: 'b', title: 'Beta', status: 'done', points: 8 })
+  await resource.create({ id: 'c', title: 'Gamma', status: 'open', points: 1 })
+
+  return resource
+}
+
+describe('@owlmeans/state — reads', () => {
+  test('list() is unpaged and always reports the total', async () => {
+    const resource = await seeded()
+    const result = await resource.list()
+    expect(result.items.map(item => item.id)).toEqual(['a', 'b', 'c'])
+    expect(result.total).toBe(3)
+  })
+
+  test('list(where, opts) filters, sorts and pages', async () => {
+    const resource = await seeded()
+    const first = await resource.list(
+      { status: ['open', 'done'] },
+      { page: 0, size: 2, sort: [{ field: 'points', order: 'desc' }] }
+    )
+    expect(first.items.map(item => item.id)).toEqual(['b', 'a'])
+    expect(first.total).toBe(3)
+
+    const second = await resource.list(
+      { status: ['open', 'done'] },
+      { page: 1, size: 2, sort: [{ field: 'points', order: 'desc' }] }
+    )
+    expect(second.items.map(item => item.id)).toEqual(['c'])
+  })
+
+  // The store is unpaged, so a page number alone has no page size to count from. Answering with
+  // everything would silently ignore what the caller asked for.
+  test('a page without a size is refused', async () => {
+    const resource = await seeded()
+    await expect(resource.list(undefined, { page: 1 })).rejects.toThrow()
+  })
+
+  test('count() answers without carrying the records', async () => {
+    const resource = await seeded()
+    expect(await resource.count()).toBe(3)
+    expect(await resource.count({ status: 'open' })).toBe(2)
+  })
+
+  test('one record by id or by criteria', async () => {
+    const resource = await seeded()
+    expect((await resource.load('a'))?.title).toBe('Alpha')
+    expect((await resource.load({ status: 'done' }))?.id).toBe('b')
+    expect((await resource.load({ status: 'missing' }))).toBeNull()
+    expect((await resource.load('zz'))).toBeNull()
+
+    expect((await resource.get({ title: 'Gamma' })).id).toBe('c')
+    await expect(resource.get('zz')).rejects.toThrow()
+    await expect(resource.get({ status: 'missing' })).rejects.toThrow()
+  })
+
+  test('a sort picks which of several matches comes first', async () => {
+    const resource = await seeded()
+    const lowest = await resource.get({ status: 'open' }, { sort: ['points'] })
+    expect(lowest.id).toBe('c')
+  })
+})
+
+describe('@owlmeans/state — writes', () => {
+  test('create refuses a record that is already there', async () => {
+    const resource = await seeded()
+    await expect(resource.create({ id: 'a' })).rejects.toThrow()
+  })
+
+  test('update replaces the record and refuses an unknown one', async () => {
+    const resource = await seeded()
+    await resource.update({ id: 'a', title: 'Renamed' })
+    const record = await resource.get('a')
+    expect(record.title).toBe('Renamed')
+    expect(record.status).toBeUndefined()
+
+    await expect(resource.update({ id: 'zz' })).rejects.toThrow()
+  })
+
+  test('save creates or replaces', async () => {
+    const resource = await seeded()
+    await resource.save({ id: 'd', title: 'Delta' })
+    await resource.save({ id: 'a', title: 'Alpha again' })
+    expect(await resource.count()).toBe(4)
+    expect((await resource.get('a')).title).toBe('Alpha again')
+  })
+
+  // Nothing here mints ids, so a record without one is misfiled rather than new — inventing a key
+  // would put a record in the store that no screen can ever address again.
+  test('a write without an id is a configuration error', async () => {
+    const resource = await seeded()
+    await expect(resource.save({ title: 'nameless' })).rejects.toThrow(StateConfigError)
+  })
+
+  test('the store keeps nothing that expires, so a ttl is refused', async () => {
+    const resource = await seeded()
+    await expect(resource.save({ id: 'a' }, { ttl: 60 })).rejects.toThrow()
+  })
+
+  test('delete answers with null, take throws', async () => {
+    const resource = await seeded()
+    expect((await resource.delete('a'))?.id).toBe('a')
+    expect(await resource.delete('a')).toBeNull()
+
+    expect((await resource.take('b')).id).toBe('b')
+    await expect(resource.take('b')).rejects.toThrow()
+  })
+
+  test('purge removes the matching records and refuses to empty the store', async () => {
+    const resource = await seeded()
+    await expect(resource.purge({})).rejects.toThrow()
+    expect(await resource.purge({ status: 'open' })).toBe(2)
+    expect((await resource.list()).items.map(item => item.id)).toEqual(['b'])
+  })
+
+  test('replace makes the store agree with an authoritative list', async () => {
+    const resource = await seeded()
+    await resource.replace([
+      { id: 'a', title: 'Alpha', status: 'done' },
+      { id: 'z', title: 'Zeta', status: 'open' }
+    ])
+    const { items } = await resource.list()
+    expect(items.map(item => item.id)).toEqual(['a', 'z'])
+    expect((await resource.get('a')).status).toBe('done')
+  })
+
+  test('clear drops everything', async () => {
+    const resource = await seeded()
+    await resource.clear()
+    expect(await resource.count()).toBe(0)
+  })
+})
+
+describe('@owlmeans/state — watching one record', () => {
+  // The whole point of the model: a subscription READS the store, it does not seed it. A screen
+  // bound to an id that has not arrived must not put a blank row into every list reading the same
+  // resource.
+  test('an id subscription creates NOTHING', async () => {
+    const resource = await seeded()
+    const seen: StateModel<Task>[] = []
+    const stop = resource.watch('zz', model => { seen.push(model) })
+
+    expect(await resource.count()).toBe(3)
+    expect(await resource.load('zz')).toBeNull()
+    expect(seen).toHaveLength(1)
+    expect(seen[0]!.empty).toBe(true)
+    expect(seen[0]!.id).toBe('zz')
+
+    stop()
+  })
+
+  test('an empty model shows the configured default and stays out of the store', async () => {
+    const resource = createStateResource<Task>('drafts', {
+      default: () => ({ title: 'Untitled', status: 'draft' })
+    })
+    let model!: StateModel<Task>
+    const stop = resource.watch('new', current => { model = current })
+
+    expect(model.empty).toBe(true)
+    expect(model.record.title).toBe('Untitled')
+    expect(await resource.count()).toBe(0)
+
+    stop()
+  })
+
+  test('the listener is seeded synchronously and follows the record', async () => {
+    const resource = await seeded()
+    const titles: Array<string | undefined> = []
+    const stop = resource.watch('a', model => { titles.push(model.record.title) })
+
+    expect(titles).toEqual(['Alpha'])
+
+    await resource.save({ id: 'a', title: 'Renamed' })
+    expect(titles.at(-1)).toBe('Renamed')
+
+    await resource.delete('a')
+    expect(titles.at(-1)).toBeUndefined()
+
+    stop()
+    await resource.save({ id: 'a', title: 'Back' })
+    expect(titles).toHaveLength(3)
+  })
+
+  test('a model written through stops being empty', async () => {
+    const resource = await seeded()
+    let model!: StateModel<Task>
+    const stop = resource.watch('zz', current => { model = current })
+
+    const written = await model.update({ title: 'Zulu' })
+    expect(written.id).toBe('zz')
+    expect((await resource.get('zz')).title).toBe('Zulu')
+
+    // The listener has been handed a fresh model by now; the one written through knows it landed.
+    expect(model.empty).toBe(false)
+
+    await model.clear()
+    expect(await resource.load('zz')).toBeNull()
+
+    stop()
+  })
+
+  /**
+   * A screen binds to `watch(project.id)` while the project is still loading, so an absent id is
+   * a rendering state and must not take the component tree down with it. Reading with no id is a
+   * different question — there the caller has lost track of which record it meant.
+   */
+  test('watching with no id reports empty rather than throwing', async () => {
+    const resource = await seeded()
+    let model!: StateModel<Session>
+    const stop = resource.watch(undefined, current => { model = current })
+
+    expect(model.empty).toBe(true)
+    expect(model.id).toBeUndefined()
+
+    stop()
+  })
+
+  test('the empty model is one reference, so a subscriber sees no change', async () => {
+    const resource = await seeded()
+    const seen: StateModel<Session>[] = []
+    const first = resource.watch(undefined, current => { seen.push(current) })
+    const second = resource.watch(undefined, current => { seen.push(current) })
+
+    expect(seen).toHaveLength(2)
+    expect(seen[0]).toBe(seen[1])
+
+    first()
+    second()
+  })
+
+  test('writing through the empty model is refused', async () => {
+    const resource = await seeded()
+    let model!: StateModel<Session>
+    const stop = resource.watch(undefined, current => { model = current })
+
+    await expect(model.update({ token: 'x' } as Partial<Session>)).rejects.toThrow(StateConfigError)
+
+    stop()
+  })
+
+  /**
+   * The reason the empty model exists at all: the store it stands in for must be untouched. The
+   * placeholder record this replaced put a blank row into every list reading the same store.
+   */
+  test('watching with no id writes nothing into the store', async () => {
+    const resource = await seeded()
+    const before = await resource.list()
+    const stop = resource.watch(undefined, () => { })
+    const after = await resource.list()
+
+    expect(after.total).toBe(before.total)
+    expect(after.items.some(item => item.id == null)).toBe(false)
+
+    stop()
+  })
+})
+
+describe('@owlmeans/state — a single resource', () => {
+  test('one slot, addressed without an id', async () => {
+    const resource = createStateResource<Session>('session', { single: true })
+    let model!: StateModel<Session>
+    const stop = resource.watch(undefined, current => { model = current })
+
+    expect(model.empty).toBe(true)
+
+    await resource.save({ token: 'first', user: 'ann' })
+    expect(model.empty).toBe(false)
+    expect(model.record.token).toBe('first')
+
+    await resource.save({ token: 'second', user: 'bob' })
+    expect(await resource.count()).toBe(1)
+    expect(model.record.user).toBe('bob')
+
+    await model.clear()
+    expect(await resource.count()).toBe(0)
+
+    stop()
+  })
+
+  test('the one record still answers only to its own id', async () => {
+    const resource = createStateResource<Session>('session-id', { single: true })
+    await resource.save({ id: 'sid', token: 'a' })
+    expect((await resource.load('sid'))?.token).toBe('a')
+    expect(await resource.load('other')).toBeNull()
+  })
+})
+
+describe('@owlmeans/state — a custom id field', () => {
+  test('records are keyed by the configured field', async () => {
+    const resource = createStateResource<Doc>('docs', { id: 'key' })
+    await resource.save({ key: 'intro', body: 'hello' })
+    await resource.save({ key: 'outro', body: 'bye' })
+
+    expect((await resource.get('intro')).body).toBe('hello')
+    expect(await resource.count()).toBe(2)
+    await expect(resource.save({ body: 'orphan' })).rejects.toThrow(StateConfigError)
+  })
+})
+
+describe('@owlmeans/state — live queries', () => {
+  test('a query subscriber is seeded and follows every write that changes the answer', async () => {
+    const resource = await seeded()
+    const seen: string[][] = []
+    const stop = resource.query({ status: 'open' }, models => {
+      seen.push(models.map(model => model.record.id!))
+    })
+
+    expect(seen.at(-1)).toEqual(['a', 'c'])
+
+    await resource.create({ id: 'd', title: 'Delta', status: 'open' })
+    expect(seen.at(-1)).toEqual(['a', 'c', 'd'])
+
+    await resource.save({ id: 'a', status: 'done' })
+    expect(seen.at(-1)).toEqual(['c', 'd'])
+
+    await resource.delete('c')
+    expect(seen.at(-1)).toEqual(['d'])
+
+    stop()
+    await resource.create({ id: 'e', status: 'open' })
+    expect(seen.at(-1)).toEqual(['d'])
+  })
+
+  test('a query subscription creates nothing', async () => {
+    const resource = createStateResource<Task>('empty')
+    const stop = resource.query({ status: 'open' }, () => { })
+    expect(await resource.count()).toBe(0)
+    stop()
+  })
+
+  test('an absent query matches everything and takes the sort', async () => {
+    const resource = await seeded()
+    let ids: string[] = []
+    const stop = resource.query(undefined, models => {
+      ids = models.map(model => model.record.id!)
+    }, { sort: [{ field: 'points', order: 'desc' }] })
+
+    expect(ids).toEqual(['b', 'a', 'c'])
+    stop()
+  })
+
+  // A write that leaves the answer alone must not re-render the screens reading it.
+  test('an unchanged answer is not announced again', async () => {
+    const resource = await seeded()
+    let calls = 0
+    const stop = resource.query({ status: 'open' }, () => { calls += 1 })
+    expect(calls).toBe(1)
+
+    await resource.save({ id: 'b', status: 'done', title: 'Beta reworded' })
+    expect(calls).toBe(1)
+
+    await resource.save({ id: 'b', status: 'open' })
+    expect(calls).toBe(2)
+
+    stop()
+  })
+})
+
+describe('@owlmeans/state — the change stream', () => {
+  test('every write announces itself', async () => {
+    const resource = await seeded()
+    const events: StateEvent<Task>[] = []
+    const stop = await resource.subscribe(event => { events.push(event) })
+
+    await resource.save({ id: 'd', title: 'Delta' })
+    expect(events.at(-1)?.type).toBe('set')
+    expect(events.at(-1)?.records.map(record => record.id)).toEqual(['d'])
+
+    await resource.purge({ status: 'open' })
+    expect(events.at(-1)?.type).toBe('remove')
+    expect(events.at(-1)?.records.map(record => record.id)).toEqual(['a', 'c'])
+
+    await stop()
+    await resource.save({ id: 'e' })
+    expect(events).toHaveLength(2)
+  })
+
+  test('a once subscriber hears one event, and a channel keeps its traffic apart', async () => {
+    const resource = await seeded()
+    let once = 0
+    await resource.subscribe(() => { once += 1 }, { once: true })
+
+    const aside: StateEvent<Task>[] = []
+    const stop = await resource.subscribe(event => { aside.push(event) }, { channel: 'aside' })
+
+    await resource.save({ id: 'd' })
+    await resource.save({ id: 'f' })
+    expect(once).toBe(1)
+    expect(aside).toHaveLength(0)
+
+    await resource.publish({ type: 'set', records: [{ id: 'd' }] }, 'aside')
+    expect(aside).toHaveLength(1)
+
+    await stop()
+  })
+})

package/tsconfig.json

@@ -6,5 +6,10 @@
     "rootDir": "./src/",
     "outDir": "./build/"
   },
-  "exclude": ["./dist/**/*", "./build/**/*", "./*.ts"]
+  "exclude": [
+    "./dist/**/*",
+    "./build/**/*",
+    "./tests/**/*",
+    "./*.ts"
+  ]
 }

package/build/consts.d.ts

@@ -1,3 +0,0 @@
-export declare const DEFAULT_ID = "_default";
-export declare const DEFAULT_ALIAS = "state";
-//# sourceMappingURL=consts.d.ts.map

package/build/consts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,UAAU,aAAa,CAAA;AACpC,eAAO,MAAM,aAAa,UAAU,CAAA"}