@livestore/common 0.4.0-dev.2 → 0.4.0-dev.20

package/dist/sync/next/graphology.js

@@ -1,30 +0,0 @@
-// TODO re-enable when `graphology` supports ESM `exports` and `.js` import/export syntax
-// import {} from 'graphology'
-import * as graphology_ from 'graphology';
-export const graphology = graphology_;
-export const DirectedGraph = class DirectedGraph extends graphology.DirectedGraph {
-};
-export const Graph = class Graph extends graphology.Graph {
-};
-// export const graphology = graphology_ as graphologyTypes
-/*
-
-Example usage:
-
-const dag = new graphology.DirectedGraph({ allowSelfLoops: false })
-
-nodes.forEach((node) => dag.addNode(node.id, { width: node.data.label.length * 100, height: 40 }))
-edges.forEach((edge) => {
-    // TODO do this filtering earlier
-    if (!nodeIds.has(edge.source) || !nodeIds.has(edge.target)) return
-
-    dag.addEdge(edge.source, edge.target)
-})
-
-graphologyLayout.random.assign(dag) // needed for initial `x`, `y` values
-const sensibleSettings = forceAtlas2.inferSettings(dag)
-// forceAtlas2.assign(dag, { iterations: 100, settings: { adjustSizes: true,  } })
-forceAtlas2.assign(dag, { iterations: 100, settings: sensibleSettings })
-
-*/
-//# sourceMappingURL=graphology.js.map

package/dist/sync/next/graphology.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"graphology.js","sourceRoot":"","sources":["../../../src/sync/next/graphology.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,8BAA8B;AAC9B,OAAO,KAAK,WAAW,MAAM,YAAY,CAAA;AAGzC,MAAM,CAAC,MAAM,UAAU,GAAG,WAAkB,CAAA;AAU5C,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,aAAc,SAAQ,UAAU,CAAC,aAAa;CAAoB,CAAA;AAErG,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,KAAM,SAAQ,UAAU,CAAC,KAAK;CAAoB,CAAA;AAE7E,2DAA2D;AAE3D;;;;;;;;;;;;;;;;;;;EAmBE"}

package/dist/sync/next/graphology_.d.ts

@@ -1,3 +0,0 @@
-export { default as graphologyDag } from 'graphology-dag';
-export * as graphology from './graphology.ts';
-//# sourceMappingURL=graphology_.d.ts.map

package/dist/sync/next/graphology_.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"graphology_.d.ts","sourceRoot":"","sources":["../../../src/sync/next/graphology_.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACzD,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA"}

package/dist/sync/next/graphology_.js

@@ -1,3 +0,0 @@
-export { default as graphologyDag } from 'graphology-dag';
-export * as graphology from "./graphology.js";
-//# sourceMappingURL=graphology_.js.map

package/dist/sync/next/graphology_.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"graphology_.js","sourceRoot":"","sources":["../../../src/sync/next/graphology_.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACzD,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA"}

package/src/schema/EventDef.ts

@@ -1,219 +0,0 @@
-import type { SingleOrReadonlyArray } from '@livestore/utils'
-import { shouldNeverHappen } from '@livestore/utils'
-import { Schema } from '@livestore/utils/effect'
-
-import type { BindValues } from '../sql-queries/sql-queries.ts'
-import type { ParamsObject } from '../util.ts'
-import type { QueryBuilder } from './state/sqlite/query-builder/mod.ts'
-
-export type EventDefMap = {
-  map: Map<string, EventDef.Any>
-}
-export type EventDefRecord = {
-  [name: string]: EventDef.Any
-}
-
-export type EventDef<TName extends string, TType, TEncoded = TType, TDerived extends boolean = false> = {
-  name: TName
-  schema: Schema.Schema<TType, TEncoded>
-  options: {
-    /**
-     * When set to true, the mutation won't be synced across clients but
-     */
-    clientOnly: boolean
-    /** Warning: This feature is not fully implemented yet */
-    facts: FactsCallback<TType> | undefined
-    derived: TDerived
-  }
-
-  /** Helper function to construct a partial event */
-  (
-    args: TType,
-  ): {
-    name: TName
-    args: TType
-  }
-
-  /** Helper function to construct a partial encoded event */
-  encoded: (args: TEncoded) => {
-    name: TName
-    args: TEncoded
-  }
-
-  readonly Event: {
-    name: TName
-    args: TType
-  }
-}
-
-export type FactsCallback<TTo> = (
-  args: TTo,
-  currentFacts: EventDefFacts,
-) => {
-  modify: {
-    set: Iterable<EventDefFactInput>
-    unset: Iterable<EventDefFactInput>
-  }
-  require: Iterable<EventDefFactInput>
-}
-
-export namespace EventDef {
-  export type Any = EventDef<string, any, any, boolean>
-
-  export type AnyWithoutFn = Pick<Any, 'name' | 'schema' | 'options'>
-}
-
-export type EventDefKey = string
-export type EventDefFact = string
-export type EventDefFacts = ReadonlyMap<string, any>
-
-export type EventDefFactsGroup = {
-  modifySet: EventDefFacts
-  modifyUnset: EventDefFacts
-
-  /**
-   * Events on independent "dependency" branches are commutative which can facilitate more prioritized syncing
-   */
-  depRequire: EventDefFacts
-  depRead: EventDefFacts
-}
-
-export type EventDefFactsSnapshot = Map<string, any>
-
-export type EventDefFactInput = string | readonly [string, any]
-
-export const defineFacts = <
-  TRecord extends Record<string, EventDefFactInput | ((...args: any[]) => EventDefFactInput)>,
->(
-  record: TRecord,
-): TRecord => record
-
-export type DefineEventOptions<TTo, TDerived extends boolean = false> = {
-  // TODO actually implement this
-  // onError?: (error: any) => void
-  /** Warning: This feature is not fully implemented yet */
-  facts?: (
-    args: TTo,
-    currentFacts: EventDefFacts,
-  ) => {
-    modify?: {
-      set?: Iterable<EventDefFactInput>
-      unset?: Iterable<EventDefFactInput>
-    }
-    /**
-     * Two purposes: constrain history and constrain compaction
-     */
-    require?: Iterable<EventDefFactInput>
-  }
-  /**
-   * When set to true, the event won't be synced over the network
-   */
-  clientOnly?: boolean
-  derived?: TDerived
-}
-
-export const defineEvent = <TName extends string, TType, TEncoded = TType, TDerived extends boolean = false>(
-  args: {
-    name: TName
-    schema: Schema.Schema<TType, TEncoded>
-  } & DefineEventOptions<TType, TDerived>,
-): EventDef<TName, TType, TEncoded, TDerived> => {
-  const { name, schema, ...options } = args
-
-  const makePartialEvent = (args: TType) => {
-    const res = Schema.validateEither(schema)(args)
-    if (res._tag === 'Left') {
-      shouldNeverHappen(`Invalid event args for event '${name}':`, res.left.message, '\n')
-    }
-    return { name: name, args }
-  }
-
-  Object.defineProperty(makePartialEvent, 'name', { value: name })
-  Object.defineProperty(makePartialEvent, 'schema', { value: schema })
-  Object.defineProperty(makePartialEvent, 'encoded', {
-    value: (args: TEncoded) => ({ name: name, args }),
-  })
-
-  Object.defineProperty(makePartialEvent, 'options', {
-    value: {
-      clientOnly: options?.clientOnly ?? false,
-      facts: options?.facts
-        ? (args, currentFacts) => {
-            const res = options.facts!(args, currentFacts)
-            return {
-              modify: {
-                set: res.modify?.set ? new Set(res.modify.set) : new Set(),
-                unset: res.modify?.unset ? new Set(res.modify.unset) : new Set(),
-              },
-              require: res.require ? new Set(res.require) : new Set(),
-            }
-          }
-        : undefined,
-      derived: options?.derived ?? false,
-    } satisfies EventDef.Any['options'],
-  })
-
-  return makePartialEvent as EventDef<TName, TType, TEncoded, TDerived>
-}
-
-export const synced = <TName extends string, TType, TEncoded = TType>(
-  args: {
-    name: TName
-    schema: Schema.Schema<TType, TEncoded>
-  } & Omit<DefineEventOptions<TType, false>, 'derived' | 'clientOnly'>,
-): EventDef<TName, TType, TEncoded> => defineEvent({ ...args, clientOnly: false })
-
-export const clientOnly = <TName extends string, TType, TEncoded = TType>(
-  args: {
-    name: TName
-    schema: Schema.Schema<TType, TEncoded>
-  } & Omit<DefineEventOptions<TType, false>, 'derived' | 'clientOnly'>,
-): EventDef<TName, TType, TEncoded> => defineEvent({ ...args, clientOnly: true })
-
-export type MaterializerResult =
-  | {
-      sql: string
-      bindValues: BindValues
-      writeTables?: ReadonlySet<string>
-    }
-  | QueryBuilder.Any
-  | string
-
-export type MaterializerContextQuery = {
-  (args: { query: string; bindValues: ParamsObject }): ReadonlyArray<unknown>
-  <TResult>(qb: QueryBuilder<TResult, any, any>): TResult
-}
-
-export type Materializer<TEventDef extends EventDef.AnyWithoutFn = EventDef.AnyWithoutFn> = (
-  event: TEventDef['schema']['Type'],
-  context: {
-    currentFacts: EventDefFacts
-    eventDef: TEventDef
-    /** Can be used to query the current state */
-    query: MaterializerContextQuery
-  },
-) => SingleOrReadonlyArray<MaterializerResult>
-
-export const defineMaterializer = <TEventDef extends EventDef.AnyWithoutFn>(
-  _eventDef: TEventDef,
-  materializer: Materializer<TEventDef>,
-): Materializer<TEventDef> => {
-  return materializer
-}
-
-export const materializers = <TInputRecord extends Record<string, EventDef.AnyWithoutFn>>(
-  _eventDefRecord: TInputRecord,
-  handlers: {
-    [TEventName in TInputRecord[keyof TInputRecord]['name'] as Extract<
-      TInputRecord[keyof TInputRecord],
-      { name: TEventName }
-    >['options']['derived'] extends true
-      ? never
-      : TEventName]: Materializer<Extract<TInputRecord[keyof TInputRecord], { name: TEventName }>>
-    // [K in TInputRecord[keyof TInputRecord]['name']]: Materializer<
-    //   Extract<TInputRecord[keyof TInputRecord], { name: K }>
-    // >
-  },
-) => {
-  return handlers
-}

package/src/schema/EventSequenceNumber.ts

@@ -1,199 +0,0 @@
-import { Brand, Schema } from '@livestore/utils/effect'
-
-export type ClientEventSequenceNumber = Brand.Branded<number, 'ClientEventSequenceNumber'>
-export const localEventSequenceNumber = Brand.nominal<ClientEventSequenceNumber>()
-export const ClientEventSequenceNumber = Schema.fromBrand(localEventSequenceNumber)(Schema.Int)
-
-export type GlobalEventSequenceNumber = Brand.Branded<number, 'GlobalEventSequenceNumber'>
-export const globalEventSequenceNumber = Brand.nominal<GlobalEventSequenceNumber>()
-export const GlobalEventSequenceNumber = Schema.fromBrand(globalEventSequenceNumber)(Schema.Int)
-
-export const clientDefault = 0 as any as ClientEventSequenceNumber
-
-export const rebaseGenerationDefault = 0
-
-/**
- * LiveStore event sequence number value consisting of a globally unique event sequence number
- * and a client sequence number.
- *
- * The client sequence number is only used for clientOnly events and starts from 0 for each global sequence number.
- */
-export type EventSequenceNumber = {
-  global: GlobalEventSequenceNumber
-  client: ClientEventSequenceNumber
-  /**
-   * Generation integer that is incremented whenever the client rebased.
-   * Starts from and resets to 0 for each global sequence number.
-   */
-  rebaseGeneration: number
-}
-
-export type EventSequenceNumberInput =
-  | EventSequenceNumber
-  | (Omit<typeof EventSequenceNumber.Encoded, 'rebaseGeneration'> & { rebaseGeneration?: number })
-
-// TODO adjust name to `ClientEventSequenceNumber`
-/**
- * NOTE: Client mutation events with a non-0 client id, won't be synced to the sync backend.
- */
-export const EventSequenceNumber = Schema.Struct({
-  global: GlobalEventSequenceNumber,
-  /** Only increments for clientOnly events */
-  client: ClientEventSequenceNumber,
-
-  // TODO also provide a way to see "confirmation level" of event (e.g. confirmed by leader/sync backend)
-
-  // Client only
-  rebaseGeneration: Schema.Int,
-}).annotations({
-  title: 'LiveStore.EventSequenceNumber',
-  pretty: () => (seqNum) => toString(seqNum),
-})
-
-/**
- * Compare two event sequence numbers i.e. checks if the first event sequence number is less than the second.
- * Comparison hierarchy: global > client > rebaseGeneration
- */
-export const compare = (a: EventSequenceNumber, b: EventSequenceNumber) => {
-  if (a.global !== b.global) {
-    return a.global - b.global
-  }
-  if (a.client !== b.client) {
-    return a.client - b.client
-  }
-  return a.rebaseGeneration - b.rebaseGeneration
-}
-
-/**
- * Convert an event sequence number to a string representation.
- */
-export const toString = (seqNum: EventSequenceNumber) => {
-  const rebaseGenerationStr = seqNum.rebaseGeneration > 0 ? `r${seqNum.rebaseGeneration}` : ''
-  return seqNum.client === 0
-    ? `e${seqNum.global}${rebaseGenerationStr}`
-    : `e${seqNum.global}+${seqNum.client}${rebaseGenerationStr}`
-}
-
-/**
- * Convert a string representation of an event sequence number to an event sequence number.
- * Parses strings in the format: e{global}[+{client}][r{rebaseGeneration}]
- * Examples: "e0", "e0r1", "e0+1", "e0+1r1"
- */
-export const fromString = (str: string): EventSequenceNumber => {
-  if (!str.startsWith('e')) {
-    throw new Error('Invalid event sequence number string: must start with "e"')
-  }
-
-  // Remove the 'e' prefix
-  const remaining = str.slice(1)
-
-  // Parse rebase generation if present
-  let rebaseGeneration = rebaseGenerationDefault
-  let withoutRebase = remaining
-  const rebaseMatch = remaining.match(/r(\d+)$/)
-  if (rebaseMatch !== null) {
-    rebaseGeneration = Number.parseInt(rebaseMatch[1]!, 10)
-    withoutRebase = remaining.slice(0, -rebaseMatch[0].length)
-  }
-
-  // Parse global and client parts
-  const parts = withoutRebase.split('+')
-
-  // Validate that parts contain only digits (and possibly empty for client)
-  if (parts[0] === '' || !/^\d+$/.test(parts[0]!)) {
-    throw new Error('Invalid event sequence number string: invalid number format')
-  }
-
-  if (parts.length > 1 && parts[1] !== undefined && (parts[1] === '' || !/^\d+$/.test(parts[1]))) {
-    throw new Error('Invalid event sequence number string: invalid number format')
-  }
-
-  const global = Number.parseInt(parts[0]!, 10)
-  const client = parts.length > 1 && parts[1] !== undefined ? Number.parseInt(parts[1], 10) : 0
-
-  if (Number.isNaN(global) || Number.isNaN(client) || Number.isNaN(rebaseGeneration)) {
-    throw new TypeError('Invalid event sequence number string: invalid number format')
-  }
-
-  return {
-    global: global as any as GlobalEventSequenceNumber,
-    client: client as any as ClientEventSequenceNumber,
-    rebaseGeneration,
-  }
-}
-
-export const fromGlobal = (seqNum: GlobalEventSequenceNumber) => ({
-  global: seqNum,
-  client: clientDefault,
-  rebaseGeneration: rebaseGenerationDefault,
-})
-
-export const isEqual = (a: EventSequenceNumber, b: EventSequenceNumber) =>
-  a.global === b.global && a.client === b.client && a.rebaseGeneration === b.rebaseGeneration
-
-export type EventSequenceNumberPair = { seqNum: EventSequenceNumber; parentSeqNum: EventSequenceNumber }
-
-export const ROOT = {
-  global: 0 as any as GlobalEventSequenceNumber,
-  client: clientDefault,
-  rebaseGeneration: rebaseGenerationDefault,
-} satisfies EventSequenceNumber
-
-export const isGreaterThan = (a: EventSequenceNumber, b: EventSequenceNumber) => {
-  return a.global > b.global || (a.global === b.global && a.client > b.client)
-}
-
-export const isGreaterThanOrEqual = (a: EventSequenceNumber, b: EventSequenceNumber) => {
-  return a.global > b.global || (a.global === b.global && a.client >= b.client)
-}
-
-export const max = (a: EventSequenceNumber, b: EventSequenceNumber) => {
-  return a.global > b.global || (a.global === b.global && a.client > b.client) ? a : b
-}
-
-export const diff = (a: EventSequenceNumber, b: EventSequenceNumber) => {
-  return {
-    global: a.global - b.global,
-    client: a.client - b.client,
-  }
-}
-
-export const make = (seqNum: EventSequenceNumberInput): EventSequenceNumber => {
-  return Schema.is(EventSequenceNumber)(seqNum)
-    ? seqNum
-    : Schema.decodeSync(EventSequenceNumber)({
-        ...seqNum,
-        rebaseGeneration: seqNum.rebaseGeneration ?? rebaseGenerationDefault,
-      })
-}
-
-export const nextPair = ({
-  seqNum,
-  isClient,
-  rebaseGeneration,
-}: {
-  seqNum: EventSequenceNumber
-  isClient: boolean
-  rebaseGeneration?: number
-}): EventSequenceNumberPair => {
-  if (isClient) {
-    return {
-      seqNum: {
-        global: seqNum.global,
-        client: (seqNum.client + 1) as any as ClientEventSequenceNumber,
-        rebaseGeneration: rebaseGeneration ?? seqNum.rebaseGeneration,
-      },
-      parentSeqNum: seqNum,
-    }
-  }
-
-  return {
-    seqNum: {
-      global: (seqNum.global + 1) as any as GlobalEventSequenceNumber,
-      client: clientDefault,
-      rebaseGeneration: rebaseGenerationDefault,
-    },
-    // NOTE we always point to `client: 0` for non-clientOnly events
-    parentSeqNum: { global: seqNum.global, client: clientDefault, rebaseGeneration: seqNum.rebaseGeneration },
-  }
-}