@livestore/common 0.4.0-dev.0 → 0.4.0-dev.10

package/src/sync/sync-backend.ts

@@ -0,0 +1,185 @@
+import {
+  type Cause,
+  type Effect,
+  type HttpClient,
+  type KeyValueStore,
+  Option,
+  Schema,
+  type Scope,
+  type Stream,
+  type SubscriptionRef,
+} from '@livestore/utils/effect'
+import type { UnexpectedError } from '../adapter-types.ts'
+import type * as LiveStoreEvent from '../schema/LiveStoreEvent.ts'
+import type { EventSequenceNumber } from '../schema/mod.ts'
+import type { InvalidPullError, InvalidPushError, IsOfflineError } from './errors.ts'
+
+export * from './sync-backend-kv.ts'
+
+/**
+ * Those arguments can be used to implement multi-tenancy etc and are passed in from the store.
+ */
+export type MakeBackendArgs = {
+  storeId: string
+  clientId: string
+  payload: Schema.JsonValue | undefined
+}
+
+// TODO rename to `SyncProviderClientConstructor`
+export type SyncBackendConstructor<TSyncMetadata = Schema.JsonValue> = (
+  args: MakeBackendArgs,
+) => Effect.Effect<
+  SyncBackend<TSyncMetadata>,
+  UnexpectedError,
+  Scope.Scope | HttpClient.HttpClient | KeyValueStore.KeyValueStore
+>
+
+// TODO add more runtime sync metadata/metrics
+// - latency histogram
+// - number of events pushed/pulled
+// - dynamic sync backend data;
+//   - data center location (e.g. colo on CF workers)
+
+// TODO rename to `SyncProviderClient`
+export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {
+  /**
+   * Can be implemented to prepare a connection to the sync backend to speed up the first pull/push.
+   */
+  connect: Effect.Effect<void, IsOfflineError | UnexpectedError, Scope.Scope>
+  pull: (
+    cursor: Option.Option<{
+      eventSequenceNumber: EventSequenceNumber.GlobalEventSequenceNumber
+      /** Metadata is needed by some sync backends */
+      metadata: Option.Option<TSyncMetadata>
+    }>,
+    options?: {
+      /**
+       * If true, the sync backend will return a stream of events that have been pushed after the cursor.
+       *
+       * @default false
+       */
+      live?: boolean
+    },
+  ) => Stream.Stream<PullResItem<TSyncMetadata>, IsOfflineError | InvalidPullError>
+  // TODO support transactions (i.e. group of mutation events which need to be applied together)
+  push: (
+    /**
+     * Constraints for batch:
+     * - Number of events: 1-100
+     * - sequence numbers must be in ascending order
+     * */
+    batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>,
+  ) => Effect.Effect<void, IsOfflineError | InvalidPushError>
+  ping: Effect.Effect<void, IsOfflineError | UnexpectedError | Cause.TimeoutException>
+  // TODO also expose latency information additionally to whether the backend is connected
+  isConnected: SubscriptionRef.SubscriptionRef<boolean>
+  /**
+   * Metadata describing the sync backend. (Currently only used by devtools.)
+   */
+  metadata: { name: string; description: string } & Record<string, Schema.JsonValue>
+  /** Information about the sync backend capabilities. */
+  supports: {
+    /**
+     * Whether the sync backend supports the `hasMore` field in the pull response.
+     */
+    pullPageInfoKnown: boolean
+    /**
+     * Whether the sync backend supports the `live` option for the pull method and thus
+     * long-lived, reactive pull streams.
+     */
+    pullLive: boolean
+  }
+}
+
+/**
+ * Connectivity metadata emitted by sync backends.
+ */
+export const NetworkStatus = Schema.Struct({
+  /** True when the upstream sync backend is reachable and responding to health checks. */
+  isConnected: Schema.Boolean,
+  /** Unix epoch timestamp (ms) of the latest connectivity state transition. */
+  timestampMs: Schema.Number,
+  /** Devtools specific metadata describing simulator overrides. */
+  devtools: Schema.Struct({
+    /** Indicates whether the devtools latch forced the client into an offline state. */
+    latchClosed: Schema.Boolean,
+  }),
+}).annotations({ title: 'NetworkStatus' })
+
+export type NetworkStatus = typeof NetworkStatus.Type
+
+/**
+ * Runtime type guard for SyncBackend objects.
+ * Performs lightweight structural checks on the object shape.
+ */
+export const isSyncBackend = (value: unknown): value is SyncBackend<any> => {
+  if (typeof value !== 'object' || value === null) return false
+
+  const v: any = value
+  const hasCoreFns =
+    typeof v.connect === 'function' &&
+    typeof v.pull === 'function' &&
+    typeof v.push === 'function' &&
+    typeof v.ping === 'function'
+
+  const hasSupports =
+    typeof v.supports === 'object' &&
+    v.supports !== null &&
+    typeof v.supports.pullPageInfoKnown === 'boolean' &&
+    typeof v.supports.pullLive === 'boolean'
+
+  const hasMetadata =
+    typeof v.metadata === 'object' &&
+    v.metadata !== null &&
+    typeof v.metadata.name === 'string' &&
+    typeof v.metadata.description === 'string'
+
+  const hasIsConnected = typeof v.isConnected === 'object' && v.isConnected !== null
+
+  return hasCoreFns && hasSupports && hasMetadata && hasIsConnected
+}
+
+export const PullResPageInfo = Schema.Union(
+  Schema.TaggedStruct('MoreUnknown', {}),
+  Schema.TaggedStruct('MoreKnown', {
+    remaining: Schema.Number,
+  }),
+  Schema.TaggedStruct('NoMore', {}),
+)
+
+export type PullResPageInfo = typeof PullResPageInfo.Type
+
+export const pageInfoNoMore: PullResPageInfo = { _tag: 'NoMore' } as const
+export const pageInfoMoreUnknown: PullResPageInfo = { _tag: 'MoreUnknown' } as const
+export const pageInfoMoreKnown = (remaining: number): PullResPageInfo => ({ _tag: 'MoreKnown', remaining })
+
+export const pullResItemEmpty = <TSyncMetadata = Schema.JsonValue>(): PullResItem<TSyncMetadata> => ({
+  batch: [],
+  pageInfo: pageInfoNoMore,
+})
+
+export interface PullResItem<TSyncMetadata = Schema.JsonValue> {
+  batch: ReadonlyArray<{
+    eventEncoded: LiveStoreEvent.AnyEncodedGlobal
+    metadata: Option.Option<TSyncMetadata>
+  }>
+  pageInfo: PullResPageInfo
+}
+
+export const of = <TSyncMetadata = Schema.JsonValue>(obj: SyncBackend<TSyncMetadata>) => obj
+
+/**
+ * Useful to continue pulling from the last event in the batch.
+ */
+export const cursorFromPullResItem = <TSyncMetadata = Schema.JsonValue>(
+  item: PullResItem<TSyncMetadata>,
+): Option.Option<{
+  eventSequenceNumber: EventSequenceNumber.GlobalEventSequenceNumber
+  metadata: Option.Option<TSyncMetadata>
+}> => {
+  const lastEvent = item.batch.at(-1)
+  if (!lastEvent) {
+    return Option.none()
+  }
+  return Option.some({ eventSequenceNumber: lastEvent.eventEncoded.seqNum, metadata: lastEvent.metadata })
+}

package/src/sync/sync.ts

@@ -1,19 +1,8 @@
-import type { Effect, HttpClient, Option, Scope, Stream, SubscriptionRef } from '@livestore/utils/effect'
-import { Schema } from '@livestore/utils/effect'
+export * from './errors.ts'
+export * as SyncBackend from './sync-backend.ts'
 
-import type { UnexpectedError } from '../adapter-types.ts'
 import type { InitialSyncOptions } from '../leader-thread/types.ts'
-import * as EventSequenceNumber from '../schema/EventSequenceNumber.ts'
-import type * as LiveStoreEvent from '../schema/LiveStoreEvent.ts'
-
-/**
- * Those arguments can be used to implement multi-tenancy etc and are passed in from the store.
- */
-export type MakeBackendArgs = {
-  storeId: string
-  clientId: string
-  payload: Schema.JsonValue | undefined
-}
+import type { SyncBackendConstructor } from './sync-backend.ts'
 
 export type SyncOptions = {
   backend?: SyncBackendConstructor<any>
@@ -29,81 +18,9 @@ export type SyncOptions = {
    * @default 'ignore'
    * */
   onSyncError?: 'shutdown' | 'ignore'
-}
-
-// TODO rename to `SyncProviderClientConstructor`
-export type SyncBackendConstructor<TSyncMetadata = Schema.JsonValue> = (
-  args: MakeBackendArgs,
-) => Effect.Effect<SyncBackend<TSyncMetadata>, UnexpectedError, Scope.Scope | HttpClient.HttpClient>
-
-// TODO add more runtime sync metadata
-// - latency histogram
-// - number of events pushed/pulled
-// - dynamic sync backend data;
-//   - data center location (e.g. colo on CF workers)
-
-// TODO rename to `SyncProviderClient`
-export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {
   /**
-   * Can be implemented to prepare a connection to the sync backend to speed up the first pull/push.
+   * Whether the sync backend should reactively pull new events from the sync backend
+   * @default true
    */
-  connect: Effect.Effect<void, IsOfflineError | UnexpectedError, HttpClient.HttpClient | Scope.Scope>
-  pull: (
-    args: Option.Option<{
-      cursor: EventSequenceNumber.EventSequenceNumber
-      metadata: Option.Option<TSyncMetadata>
-    }>,
-  ) => Stream.Stream<
-    {
-      batch: ReadonlyArray<{
-        eventEncoded: LiveStoreEvent.AnyEncodedGlobal
-        metadata: Option.Option<TSyncMetadata>
-      }>
-      remaining: number
-    },
-    IsOfflineError | InvalidPullError,
-    HttpClient.HttpClient
-  >
-  // TODO support transactions (i.e. group of mutation events which need to be applied together)
-  push: (
-    /**
-     * Constraints for batch:
-     * - Number of events: 1-100
-     * - sequence numbers must be in ascending order
-     * */
-    batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>,
-  ) => Effect.Effect<void, IsOfflineError | InvalidPushError, HttpClient.HttpClient>
-  isConnected: SubscriptionRef.SubscriptionRef<boolean>
-  /**
-   * Metadata describing the sync backend. (Currently only used by devtools.)
-   */
-  metadata: { name: string; description: string } & Record<string, Schema.JsonValue>
+  livePull?: boolean
 }
-
-export class IsOfflineError extends Schema.TaggedError<IsOfflineError>()('IsOfflineError', {}) {}
-
-// TODO gt rid of this error in favour of SyncError
-export class InvalidPushError extends Schema.TaggedError<InvalidPushError>()('InvalidPushError', {
-  reason: Schema.Union(
-    Schema.TaggedStruct('Unexpected', {
-      message: Schema.String,
-    }),
-    Schema.TaggedStruct('ServerAhead', {
-      minimumExpectedNum: Schema.Number,
-      providedNum: Schema.Number,
-    }),
-  ),
-}) {}
-
-// TODO gt rid of this error in favour of SyncError
-export class InvalidPullError extends Schema.TaggedError<InvalidPullError>()('InvalidPullError', {
-  message: Schema.String,
-}) {}
-
-// TODO gt rid of this error in favour of SyncError
-export class LeaderAheadError extends Schema.TaggedError<LeaderAheadError>()('LeaderAheadError', {
-  minimumExpectedNum: EventSequenceNumber.EventSequenceNumber,
-  providedNum: EventSequenceNumber.EventSequenceNumber,
-  /** Generation number the client session should use for subsequent pushes */
-  // nextGeneration: Schema.Number,
-}) {}

package/src/sync/transport-chunking.ts

@@ -0,0 +1,90 @@
+import { Chunk, Effect, Schema } from '@livestore/utils/effect'
+
+const textEncoder = new TextEncoder()
+
+/**
+ * Configuration describing how to break a chunk into smaller payload-safe chunks.
+ */
+export interface ChunkingOptions<A> {
+  /** Maximum number of items that may appear in any emitted chunk. */
+  readonly maxItems: number
+  /** Maximum encoded byte size allowed for any emitted chunk. */
+  readonly maxBytes: number
+  /**
+   * Callback that produces a JSON-serialisable structure whose byte size should
+   * fit within {@link maxBytes}. This lets callers control framing overhead.
+   */
+  readonly encode: (items: ReadonlyArray<A>) => unknown
+  /**
+   * Optional custom measurement function. When provided it overrides the
+   * default {@link JSON.stringify}-based measurement logic.
+   */
+  readonly measure?: (items: ReadonlyArray<A>) => number
+}
+
+/**
+ * Derives a function that splits an input chunk into sub-chunks confined by
+ * both item count and encoded byte size limits. Designed for transports with
+ * strict frame caps (e.g. Cloudflare hibernated WebSockets).
+ */
+export class OversizeChunkItemError extends Schema.TaggedError<OversizeChunkItemError>()('OversizeChunkItemError', {
+  size: Schema.Number,
+  maxBytes: Schema.Number,
+}) {}
+
+export const splitChunkBySize =
+  <A>(options: ChunkingOptions<A>) =>
+  (chunk: Chunk.Chunk<A>): Effect.Effect<Chunk.Chunk<Chunk.Chunk<A>>, OversizeChunkItemError> =>
+    Effect.gen(function* () {
+      const maxItems = Math.max(1, options.maxItems)
+      const maxBytes = Math.max(1, options.maxBytes)
+      const encode = options.encode
+      const measure = options.measure
+
+      const computeSize = (items: ReadonlyArray<A>) => {
+        if (measure !== undefined) {
+          return measure(items)
+        }
+
+        const encoded = encode(items)
+        return textEncoder.encode(JSON.stringify(encoded)).byteLength
+      }
+
+      const items = Chunk.toReadonlyArray(chunk)
+      if (items.length === 0) {
+        return Chunk.fromIterable<Chunk.Chunk<A>>([])
+      }
+
+      const result: Array<Chunk.Chunk<A>> = []
+      let current: Array<A> = []
+
+      const flushCurrent = () => {
+        if (current.length > 0) {
+          result.push(Chunk.fromIterable(current))
+          current = []
+        }
+      }
+
+      for (const item of items) {
+        current.push(item)
+        const exceedsLimit = current.length > maxItems || computeSize(current) > maxBytes
+
+        if (exceedsLimit) {
+          // remove the item we just added and emit the previous chunk if it exists
+          const last = current.pop()!
+          flushCurrent()
+
+          if (last !== undefined) {
+            current = [last]
+            const singleItemTooLarge = computeSize(current) > maxBytes
+            if (singleItemTooLarge || current.length > maxItems) {
+              return yield* new OversizeChunkItemError({ size: computeSize([last]), maxBytes })
+            }
+          }
+        }
+      }
+
+      flushCurrent()
+
+      return Chunk.fromIterable(result)
+    })

package/src/sync/validate-push-payload.ts

@@ -1,7 +1,7 @@
 import { Effect } from '@livestore/utils/effect'
 
-import type { EventSequenceNumber, LiveStoreEvent } from '../schema/mod.ts'
-import { InvalidPushError } from './sync.ts'
+import { EventSequenceNumber, type LiveStoreEvent } from '../schema/mod.ts'
+import { InvalidPushError, ServerAheadError } from './sync.ts'
 
 // TODO proper batch validation
 export const validatePushPayload = (
@@ -11,11 +11,10 @@ export const validatePushPayload = (
   Effect.gen(function* () {
     if (batch[0]!.seqNum <= currentEventSequenceNumber) {
       return yield* InvalidPushError.make({
-        reason: {
-          _tag: 'ServerAhead',
-          minimumExpectedNum: currentEventSequenceNumber + 1,
-          providedNum: batch[0]!.seqNum,
-        },
+        cause: new ServerAheadError({
+          minimumExpectedNum: EventSequenceNumber.globalEventSequenceNumber(currentEventSequenceNumber + 1),
+          providedNum: EventSequenceNumber.globalEventSequenceNumber(batch[0]!.seqNum),
+        }),
       })
     }
   })

package/src/testing/event-factory.ts

@@ -0,0 +1,133 @@
+/**
+ * Helpers for synthesizing LiveStore events in tests while keeping track of
+ * sequence numbers, parent pointers, and authoring client identity. Inspired
+ * by the effect-based schema utilities, the factory exposes a namespaced API
+ * where each event definition maps to a helper with `next`, `advanceTo`, and
+ * `setParent` functions that share a single sequence stream.
+ *
+ * @example
+ * ```ts
+ * import { EventFactory } from '@livestore/common/testing'
+ * import { events } from './schema'
+ *
+ * const eventFactory = EventFactory.makeFactory(events)({
+ *   client: EventFactory.clientIdentity('test-client'),
+ *   startSeq: 1,
+ *   initialParent: 'root',
+ * })
+ *
+ * const bootstrap = eventFactory.todoCreated.next({
+ *   id: 'todo-1',
+ *   text: 'write tests',
+ *   completed: false,
+ * })
+ *
+ * eventFactory.todoCreated.advanceTo(42)
+ * const branched = eventFactory.todoUpdated.next({
+ *   id: 'todo-1',
+ *   text: 'ship feature',
+ *   completed: true,
+ * })
+ * ```
+ */
+
+import { Schema } from '@livestore/utils/effect'
+
+import type { EventDef } from '../schema/EventDef.ts'
+import * as EventSequenceNumber from '../schema/EventSequenceNumber.ts'
+import * as LiveStoreEvent from '../schema/LiveStoreEvent.ts'
+
+export interface ClientIdentity {
+  clientId: string
+  sessionId: string
+}
+
+export const clientIdentity = (label: string, session = `${label}-session`): ClientIdentity => ({
+  clientId: label,
+  sessionId: session,
+})
+
+export type SequenceValue = 'root' | number
+
+type EventFactoriesArgs<TDefs extends Record<string, EventDef.Any>> = {
+  [K in keyof TDefs]: Parameters<TDefs[K]>[0]
+}
+
+type EventFactories<TDefs extends Record<string, EventDef.Any>, TResult> = {
+  [K in keyof TDefs]: {
+    next: (args: EventFactoriesArgs<TDefs>[K]) => TResult
+    advanceTo: (seq: number, parent?: SequenceValue) => void
+    setParent: (parent: SequenceValue) => void
+    current: () => { seq: number; parent: SequenceValue }
+  }
+}
+
+export interface EventFactoriesConfig {
+  client: ClientIdentity
+  /**
+   * @default 1
+   */
+  startSeq?: number
+  /**
+   * @default 0 (root)
+   */
+  initialParent?: SequenceValue
+}
+
+export const makeFactory =
+  <TDefs extends Record<string, EventDef.Any>>(eventDefs: TDefs) =>
+  ({
+    client,
+    startSeq = 1,
+    initialParent = 'root',
+  }: EventFactoriesConfig): EventFactories<TDefs, LiveStoreEvent.AnyEncodedGlobal> => {
+    let nextSeq = startSeq
+    let parentRef: SequenceValue = initialParent
+
+    const advanceTo = (seq: number, parent: SequenceValue = 'root') => {
+      nextSeq = seq
+      parentRef = parent
+    }
+
+    const setParent = (parent: SequenceValue) => {
+      parentRef = parent
+    }
+
+    const current = () => ({ seq: nextSeq, parent: parentRef })
+
+    const factories: Partial<EventFactories<TDefs, LiveStoreEvent.AnyEncodedGlobal>> = {}
+
+    for (const [name, eventDef] of Object.entries(eventDefs) as [keyof TDefs, TDefs[keyof TDefs]][]) {
+      const next = (args: EventFactoriesArgs<TDefs>[typeof name]) => {
+        const decoded = eventDef(args)
+        const encodedArgs = Schema.encodeSync(eventDef.schema)(decoded.args)
+        const encoded = eventDef.encoded(encodedArgs)
+
+        const event = LiveStoreEvent.AnyEncodedGlobal.make({
+          name: encoded.name,
+          args: encoded.args,
+          seqNum: EventSequenceNumber.globalEventSequenceNumber(nextSeq),
+          parentSeqNum:
+            parentRef === 'root'
+              ? EventSequenceNumber.ROOT.global
+              : EventSequenceNumber.globalEventSequenceNumber(parentRef),
+          clientId: client.clientId,
+          sessionId: client.sessionId,
+        })
+
+        parentRef = nextSeq
+        nextSeq = nextSeq + 1
+
+        return event
+      }
+
+      factories[name] = {
+        next,
+        advanceTo,
+        setParent,
+        current,
+      } as EventFactories<TDefs, LiveStoreEvent.AnyEncodedGlobal>[typeof name]
+    }
+
+    return factories as EventFactories<TDefs, LiveStoreEvent.AnyEncodedGlobal>
+  }

package/src/testing/mod.ts

@@ -0,0 +1 @@
+export * as EventFactory from './event-factory.ts'

package/src/version.ts

@@ -2,7 +2,7 @@
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
 
-export const liveStoreVersion = '0.4.0-dev.0' as const
+export const liveStoreVersion = '0.4.0-dev.10' as const
 
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.
@@ -11,4 +11,4 @@ export const liveStoreVersion = '0.4.0-dev.0' as const
  * While LiveStore is in beta, this might happen more frequently.
  * In the future, LiveStore will provide a migration path for older database files to avoid the impression of data loss.
  */
-export const liveStoreStorageFormatVersion = 5
+export const liveStoreStorageFormatVersion = 6

package/dist/schema-management/migrations.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=migrations.test.d.ts.map

package/dist/schema-management/migrations.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"migrations.test.d.ts","sourceRoot":"","sources":["../../src/schema-management/migrations.test.ts"],"names":[],"mappings":""}

package/dist/schema-management/migrations.test.js

@@ -1,52 +0,0 @@
-import { Option, Schema } from '@livestore/utils/effect';
-import { describe, expect, it } from 'vitest';
-import { makeColumnSpec } from './migrations.js';
-const createColumn = (name, type, options = {}) => ({
-    _tag: 'column',
-    name,
-    type: { _tag: type },
-    nullable: options.nullable ?? true,
-    primaryKey: options.primaryKey ?? false,
-    default: Option.none(),
-    schema: type === 'text' ? Schema.String : Schema.Number,
-});
-describe('makeColumnSpec', () => {
-    it('should quote column names properly for reserved keywords', () => {
-        const table = {
-            _tag: 'table',
-            name: 'blocks',
-            columns: [createColumn('order', 'integer', { nullable: false }), createColumn('group', 'text')],
-            indexes: [],
-        };
-        const result = makeColumnSpec(table);
-        expect(result).toMatchInlineSnapshot(`"'order' integer not null , 'group' text  "`);
-        expect(result).toContain("'order'");
-        expect(result).toContain("'group'");
-    });
-    it('should handle basic columns with primary keys', () => {
-        const table = {
-            _tag: 'table',
-            name: 'users',
-            columns: [createColumn('id', 'text', { nullable: false, primaryKey: true }), createColumn('name', 'text')],
-            indexes: [],
-        };
-        const result = makeColumnSpec(table);
-        expect(result).toMatchInlineSnapshot(`"'id' text not null , 'name' text  , PRIMARY KEY ('id')"`);
-        expect(result).toContain("PRIMARY KEY ('id')");
-    });
-    it('should handle multi-column primary keys', () => {
-        const table = {
-            _tag: 'table',
-            name: 'composite',
-            columns: [
-                createColumn('tenant_id', 'text', { nullable: false, primaryKey: true }),
-                createColumn('user_id', 'text', { nullable: false, primaryKey: true }),
-            ],
-            indexes: [],
-        };
-        const result = makeColumnSpec(table);
-        expect(result).toMatchInlineSnapshot(`"'tenant_id' text not null , 'user_id' text not null , PRIMARY KEY ('tenant_id', 'user_id')"`);
-        expect(result).toContain("PRIMARY KEY ('tenant_id', 'user_id')");
-    });
-});
-//# sourceMappingURL=migrations.test.js.map

package/dist/schema-management/migrations.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"migrations.test.js","sourceRoot":"","sources":["../../src/schema-management/migrations.test.ts"],"names":[],"mappings":"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"}

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

@@ -1,8 +0,0 @@
-import type * as graphologyTypes from 'graphology-types';
-export declare const graphology: any;
-export declare class IGraph<NodeAttributes extends graphologyTypes.Attributes = graphologyTypes.Attributes, EdgeAttributes extends graphologyTypes.Attributes = graphologyTypes.Attributes, GraphAttributes extends graphologyTypes.Attributes = graphologyTypes.Attributes> extends graphologyTypes.AbstractGraph<NodeAttributes, EdgeAttributes, GraphAttributes> {
-    constructor(options?: graphologyTypes.GraphOptions);
-}
-export declare const DirectedGraph: typeof IGraph;
-export declare const Graph: typeof IGraph;
-//# 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":"AAGA,OAAO,KAAK,KAAK,eAAe,MAAM,kBAAkB,CAAA;AAExD,eAAO,MAAM,UAAU,EAAkB,GAAG,CAAA;AAE5C,MAAM,CAAC,OAAO,OAAO,MAAM,CACzB,cAAc,SAAS,eAAe,CAAC,UAAU,GAAG,eAAe,CAAC,UAAU,EAC9E,cAAc,SAAS,eAAe,CAAC,UAAU,GAAG,eAAe,CAAC,UAAU,EAC9E,eAAe,SAAS,eAAe,CAAC,UAAU,GAAG,eAAe,CAAC,UAAU,CAC/E,SAAQ,eAAe,CAAC,aAAa,CAAC,cAAc,EAAE,cAAc,EAAE,eAAe,CAAC;gBAC1E,OAAO,CAAC,EAAE,eAAe,CAAC,YAAY;CACnD;AAED,eAAO,MAAM,aAAa,EAA8D,OAAO,MAAM,CAAA;AAErG,eAAO,MAAM,KAAK,EAA8C,OAAO,MAAM,CAAA"}

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"}