@dxos/echo-db 2.33.4-dev.faf06c70 → 2.33.5-dev.1fc05a51

package/src/pipeline/party-core.ts

@@ -5,10 +5,10 @@
 import assert from 'assert';
 
 import { synchronized } from '@dxos/async';
-import { KeyHint, KeyType } from '@dxos/credentials';
+import { KeyHint, KeyType, Message as HaloMessage } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
 import { timed } from '@dxos/debug';
-import { createFeedWriter, DatabaseSnapshot, PartyKey, PartySnapshot, Timeframe } from '@dxos/echo-protocol';
+import { createFeedWriter, DatabaseSnapshot, PartyKey, PartySnapshot, Timeframe, WriteReceipt } from '@dxos/echo-protocol';
 import { ModelFactory } from '@dxos/model-factory';
 import { SubscriptionGroup } from '@dxos/util';
 
@@ -202,6 +202,11 @@ export class PartyCore {
     return this;
   }
 
+  writeCredentialsMessage (message: HaloMessage): Promise<WriteReceipt> {
+    assert(this._partyProcessor, 'Party not open');
+    return this._partyProcessor?.writeHaloMessage(message);
+  }
+
   /**
    * Create a snapshot of the current state.
    */

package/src/pipeline/party-processor.ts

@@ -12,7 +12,8 @@ import {
   PartyState,
   Message as HaloMessage,
   IdentityEventType,
-  PartyEventType
+  PartyEventType,
+  SignedMessage
 } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
 import { FeedKey, FeedWriter, IHaloStream, PartyKey, HaloStateSnapshot, WriteReceipt } from '@dxos/echo-protocol';
@@ -20,10 +21,33 @@ import { jsonReplacer } from '@dxos/util';
 
 const log = debug('dxos:echo-db:party-processor');
 
+export interface CredentialWriter {
+  writeHaloMessage (message: HaloMessage): Promise<WriteReceipt>
+}
+
+export interface CredentialProcessor {
+  processMessage (message: IHaloStream): Promise<void>
+}
+
+export interface PartyStateProvider {
+  partyKey: PublicKey
+
+  /**
+   * Whether PartyGenesis was already processed.
+   */
+  genesisRequired: boolean
+  memberKeys: PublicKey[]
+  feedKeys: PublicKey[]
+  getFeedOwningMember (feedKey: FeedKey): PublicKey | undefined
+  isFeedAdmitted (feedKey: FeedKey): boolean
+
+  getOfflineInvitation (invitationID: Buffer): SignedMessage | undefined
+}
+
 /**
  * TODO(burdon): Wrapper/Bridge between HALO APIs.
  */
-export class PartyProcessor {
+export class PartyProcessor implements CredentialWriter, CredentialProcessor, PartyStateProvider {
   private readonly _state: PartyState;
 
   private _outboundHaloStream: FeedWriter<HaloMessage> | undefined;

package/src/pipeline/pipeline.test.ts

@@ -25,7 +25,7 @@ const log = debug('dxos:echo:pipeline:test');
 describe('pipeline', () => {
   test('streams', async () => {
     const storage = createStorage('', StorageType.RAM);
-    const feedStore = new FeedStore(storage, { valueEncoding: codec });
+    const feedStore = new FeedStore(storage.directory('feed'), { valueEncoding: codec });
     const feedKeys: Uint8Array[] = [];
     const feedSelector: FeedSelector = descriptor => !!feedKeys.find(key => descriptor.key.equals(key));
     const feedReadStream = new FeedStoreIterator(feedSelector, () => 0, new Timeframe());
@@ -87,7 +87,7 @@ describe('pipeline', () => {
 
   test('writing', async () => {
     const storage = createStorage('', StorageType.RAM);
-    const feedStore = new FeedStore(storage, { valueEncoding: codec });
+    const feedStore = new FeedStore(storage.directory('feed'), { valueEncoding: codec });
     const feedReadStream = new FeedStoreIterator(() => true, () => 0, new Timeframe());
 
     const { publicKey, secretKey } = createKeyPair();

package/src/pipeline/pipeline.ts

@@ -17,7 +17,7 @@ import { createReadable } from '@dxos/feed-store';
 import { jsonReplacer } from '@dxos/util';
 
 import { TimeframeClock } from '../database';
-import { PartyProcessor } from './party-processor';
+import { CredentialProcessor, PartyStateProvider } from './party-processor';
 
 interface Options {
   readLogger?: (msg: any) => void
@@ -55,17 +55,13 @@ export class Pipeline {
    * @param _options
    */
   constructor (
-    private readonly _partyProcessor: PartyProcessor,
+    private readonly _partyProcessor: CredentialProcessor & PartyStateProvider,
     private readonly _feedStorIterator: FeedStoreIterator,
     private readonly _timeframeClock: TimeframeClock,
     private readonly _feedWriter?: FeedWriter<FeedMessage>,
     private readonly _options: Options = {}
   ) {}
 
-  get partyKey () {
-    return this._partyProcessor.partyKey;
-  }
-
   get isOpen () {
     return this._inboundEchoStream !== undefined;
   }

package/src/protocol/auth-plugin.ts

@@ -9,6 +9,4 @@ import { Replicator } from '@dxos/protocol-plugin-replicator';
 /**
  * Creates authenticator network-protocol plugin that guards access to the replicator.
  */
-export function createAuthPlugin (authenticator: Authenticator, peerId: PublicKey) {
-  return new AuthPlugin(peerId.asBuffer(), authenticator, [Replicator.extension]);
-}
+export const createAuthPlugin = (authenticator: Authenticator, peerId: PublicKey) => new AuthPlugin(peerId.asBuffer(), authenticator, [Replicator.extension]);

package/src/protocol/authenticator.ts

@@ -12,19 +12,17 @@ import { CredentialsSigner } from './credentials-signer';
 
 const log = debug('dxos:echo-db:authenticator');
 
-export function createAuthenticator (partyProcessor: PartyProcessor, credentialsSigner: CredentialsSigner): Authenticator {
-  return new PartyAuthenticator(partyProcessor.state, async auth => {
-    if (auth.feedAdmit && auth.feedKey && !partyProcessor.isFeedAdmitted(auth.feedKey)) {
-      log(`Admitting feed of authenticated member: ${auth.feedKey}`);
-      await partyProcessor.writeHaloMessage(createEnvelopeMessage(
-        credentialsSigner.signer,
-        partyProcessor.partyKey,
-        auth.feedAdmit,
-        [credentialsSigner.getDeviceSigningKeys()]
-      ));
-    }
-  });
-}
+export const createAuthenticator = (partyProcessor: PartyProcessor, credentialsSigner: CredentialsSigner): Authenticator => new PartyAuthenticator(partyProcessor.state, async auth => {
+  if (auth.feedAdmit && auth.feedKey && !partyProcessor.isFeedAdmitted(auth.feedKey)) {
+    log(`Admitting feed of authenticated member: ${auth.feedKey}`);
+    await partyProcessor.writeHaloMessage(createEnvelopeMessage(
+      credentialsSigner.signer,
+      partyProcessor.partyKey,
+      auth.feedAdmit,
+      [credentialsSigner.getDeviceSigningKeys()]
+    ));
+  }
+});
 
 export interface CredentialsProvider {
   /**
@@ -33,24 +31,22 @@ export interface CredentialsProvider {
   get (): Buffer
 }
 
-export function createCredentialsProvider (credentialsSigner: CredentialsSigner, partyKey: PartyKey, feedKey: FeedKey): CredentialsProvider {
-  return {
-    get: () => {
-      const authMessage = createAuthMessage(
+export const createCredentialsProvider = (credentialsSigner: CredentialsSigner, partyKey: PartyKey, feedKey: FeedKey): CredentialsProvider => ({
+  get: () => {
+    const authMessage = createAuthMessage(
+      credentialsSigner.signer,
+      partyKey,
+      credentialsSigner.getIdentityKey(),
+      credentialsSigner.getDeviceSigningKeys(),
+      feedKey,
+      undefined,
+      createFeedAdmitMessage(
         credentialsSigner.signer,
         partyKey,
-        credentialsSigner.getIdentityKey(),
-        credentialsSigner.getDeviceSigningKeys(),
         feedKey,
-        undefined,
-        createFeedAdmitMessage(
-          credentialsSigner.signer,
-          partyKey,
-          feedKey,
-          [feedKey, credentialsSigner.getDeviceSigningKeys()]
-        )
-      );
-      return Buffer.from(codec.encode(authMessage));
-    }
-  };
-}
+        [feedKey, credentialsSigner.getDeviceSigningKeys()]
+      )
+    );
+    return Buffer.from(codec.encode(authMessage));
+  }
+});

package/src/protocol/halo-recovery-plugin.ts

@@ -12,9 +12,7 @@ import { HaloRecoveryInitiator, InvitationFactory } from '../invitations';
  * Plugin is intended to be used in HALO party swarm.
  *
  */
-export function createHaloRecoveryPlugin (identityKey: PublicKey, invitationFactory: InvitationFactory, peerId: PublicKey) {
-  return new GreetingCommandPlugin(
-    peerId.asBuffer(),
-    HaloRecoveryInitiator.createHaloInvitationClaimHandler(identityKey, invitationFactory)
-  );
-}
+export const createHaloRecoveryPlugin = (identityKey: PublicKey, invitationFactory: InvitationFactory, peerId: PublicKey) => new GreetingCommandPlugin(
+  peerId.asBuffer(),
+  HaloRecoveryInitiator.createHaloInvitationClaimHandler(identityKey, invitationFactory)
+);

package/src/protocol/identity-credentials.ts

@@ -25,7 +25,7 @@ export interface IdentityCredentials {
 
 export type IdentityCredentialsProvider = () => IdentityCredentials | undefined
 
-export async function createTestIdentityCredentials (keyring: Keyring): Promise<IdentityCredentials> {
+export const createTestIdentityCredentials = async (keyring: Keyring): Promise<IdentityCredentials> => {
   const identityKey = await keyring.createKeyRecord({ type: KeyType.IDENTITY });
   const deviceKey = await keyring.createKeyRecord({ type: KeyType.DEVICE });
   const feedKey = await keyring.createKeyRecord({ type: KeyType.FEED });
@@ -53,9 +53,9 @@ export async function createTestIdentityCredentials (keyring: Keyring): Promise<
     preferences: undefined,
     contacts: undefined
   };
-}
+};
 
-export async function deriveTestDeviceCredentials (identity: IdentityCredentials): Promise<IdentityCredentials> {
+export const deriveTestDeviceCredentials = async (identity: IdentityCredentials): Promise<IdentityCredentials> => {
   const deviceKey = await identity.keyring.createKeyRecord({ type: KeyType.DEVICE });
   const keyAdmit = createKeyAdmitMessage(identity.keyring, identity.identityKey.publicKey, deviceKey, [identity.identityKey]);
 
@@ -75,4 +75,4 @@ export async function deriveTestDeviceCredentials (identity: IdentityCredentials
       deviceKeyChain
     )
   };
-}
+};

package/src/protocol/offline-invitation-plugin.ts

@@ -11,9 +11,7 @@ import { InvitationFactory, OfflineInvitationClaimer } from '../invitations';
  * Creates network protocol plugin that allows peers to claim offline invitations.
  * Plugin is intended to be used in data-party swarms.
  */
-export function createOfflineInvitationPlugin (invitationFactory: InvitationFactory, peerId: PublicKey) {
-  return new GreetingCommandPlugin(
-    peerId.asBuffer(),
-    OfflineInvitationClaimer.createOfflineInvitationClaimHandler(invitationFactory)
-  );
-}
+export const createOfflineInvitationPlugin = (invitationFactory: InvitationFactory, peerId: PublicKey) => new GreetingCommandPlugin(
+  peerId.asBuffer(),
+  OfflineInvitationClaimer.createOfflineInvitationClaimHandler(invitationFactory)
+);

package/src/protocol/party-protocol-factory.ts

@@ -4,17 +4,13 @@
 
 import debug from 'debug';
 
-import { synchronized } from '@dxos/async';
 import { discoveryKey, keyToString, PublicKey } from '@dxos/crypto';
-import { FeedKey, PartyKey } from '@dxos/echo-protocol';
-import type { HypercoreFeed } from '@dxos/feed-store';
+import { PartyKey } from '@dxos/echo-protocol';
 import { Protocol } from '@dxos/mesh-protocol';
 import { MMSTTopology, NetworkManager, Plugin } from '@dxos/network-manager';
 import { PresencePlugin } from '@dxos/protocol-plugin-presence';
-import { Replicator } from '@dxos/protocol-plugin-replicator';
 
 import { CredentialsProvider } from '.';
-import { PartyFeedProvider } from '../pipeline/party-feed-provider';
 
 const log = debug('dxos:echo-db:party-protocol-factory');
 
@@ -23,21 +19,15 @@ const log = debug('dxos:echo-db:party-protocol-factory');
  */
 export class PartyProtocolFactory {
   private readonly _presencePlugin = new PresencePlugin(this._peerId.asBuffer());
-  private readonly _replicatorProtocolPluginFactory: ReplicatorProtocolPluginFactory;
 
   private _started = false;
 
   constructor (
     private readonly _partyKey: PartyKey,
     private readonly _networkManager: NetworkManager,
-    private readonly _feedProvider: PartyFeedProvider,
     private readonly _peerId: PublicKey,
     private readonly _credentials: CredentialsProvider
-  ) {
-    // Replication.
-    this._replicatorProtocolPluginFactory =
-      new ReplicatorProtocolPluginFactory(this._feedProvider);
-  }
+  ) {}
 
   async start (plugins: Plugin[]) {
     if (this._started) {
@@ -73,9 +63,8 @@ export class PartyProtocolFactory {
     await this._networkManager.leaveProtocolSwarm(this._partyKey);
   }
 
-  private _createProtocol (channel: any, opts: {initiator: boolean}, extraPlugins: Plugin[]) {
+  private _createProtocol (channel: any, opts: { initiator: boolean }, extraPlugins: Plugin[]) {
     const plugins: Plugin[] = [
-      ...this._replicatorProtocolPluginFactory.createPlugins(),
       ...extraPlugins,
       this._presencePlugin
     ];
@@ -118,45 +107,3 @@ export class PartyProtocolFactory {
     return protocol;
   }
 }
-
-/**
- * Creates the protocol plugin for feed replication.
- */
-export class ReplicatorProtocolPluginFactory {
-  constructor (
-    private readonly _feedProvider: PartyFeedProvider
-  ) {}
-
-  createPlugins () {
-    return [
-      new Replicator({
-        load: async () => {
-          const feeds = this._feedProvider.getFeeds();
-          log(`Loading feeds: ${feeds.map(feed => keyToString(feed.key))}`);
-          return feeds.map((feed) => ({ discoveryKey: feed.feed.discoveryKey }));
-        },
-
-        subscribe: (addFeedToReplicatedSet: (feed: any) => void) => {
-          return this._feedProvider.feedOpened.on(async (feed) => {
-            log(`Adding feed: ${feed.key.toHex()}`);
-            addFeedToReplicatedSet({ discoveryKey: feed.feed.discoveryKey });
-          });
-        },
-
-        replicate: async (remoteFeeds, info) => {
-          // We can ignore remoteFeeds entirely, since the set of feeds we want to replicate is dictated by the Party.
-          // TODO(telackey): Why are we opening feeds? Necessary or belt/braces thinking, or because open party does it?
-          const feeds = this._feedProvider.getFeeds();
-          log(`Replicating: peerId=${info.session}; feeds=${feeds.map(feed => feed.key.toHex())}`);
-          return feeds.map(feed => feed.feed);
-        }
-      })
-    ];
-  }
-
-  @synchronized
-  private async _openFeed (key: FeedKey): Promise<HypercoreFeed> {
-    const descriptor = await this._feedProvider.createOrOpenReadOnlyFeed(key);
-    return descriptor.feed;
-  }
-}

package/src/protocol/replicator-plugin.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import debug from 'debug';
+
+import { keyToString } from '@dxos/crypto';
+import { Replicator } from '@dxos/protocol-plugin-replicator';
+
+import { PartyFeedProvider } from '../pipeline';
+
+const log = debug('dxos:echo-db:protocol:replicator');
+
+/**
+ * Creates the protocol plugin for feed replication.
+ */
+export const createReplicatorPlugin = (feedProvider: PartyFeedProvider) =>
+  new Replicator({
+    load: async () => {
+      const feeds = feedProvider.getFeeds();
+      log(`Loading feeds: ${feeds.map(feed => keyToString(feed.key))}`);
+      return feeds.map((feed) => ({ discoveryKey: feed.feed.discoveryKey }));
+    },
+
+    subscribe: (addFeedToReplicatedSet: (feed: any) => void) => feedProvider.feedOpened.on(async (feed) => {
+      log(`Adding feed: ${feed.key.toHex()}`);
+      addFeedToReplicatedSet({ discoveryKey: feed.feed.discoveryKey });
+    }),
+
+    replicate: async (remoteFeeds, info) => {
+      // We can ignore remoteFeeds entirely, since the set of feeds we want to replicate is dictated by the Party.
+      // TODO(telackey): Why are we opening feeds? Necessary or belt/braces thinking, or because open party does it?
+      const feeds = feedProvider.getFeeds();
+      log(`Replicating: peerId=${info.session}; feeds=${feeds.map(feed => feed.key.toHex())}`);
+      return feeds.map(feed => feed.feed);
+    }
+  });

package/src/snapshots/snapshot-generator.ts

@@ -10,20 +10,16 @@ import { SnapshotStore } from './snapshot-store';
 
 const log = debug('dxos:snapshot-generator');
 
-export function createAutomaticSnapshots (
-  party: PartyCore, clock: TimeframeClock, store: SnapshotStore, interval: number
-) {
-  return clock.update.on(async timeframe => {
-    const totalMessages = timeframe.totalMessages();
-    if (totalMessages > 0 && totalMessages % interval === 0) {
-      log(`Saving snapshot of ${party.key.humanize()}...`);
-      try {
-        const snapshot = party.createSnapshot();
-        await store.save(snapshot);
-      } catch (err: any) {
-        console.error('Failed to save snapshot');
-        console.error(err);
-      }
+export const createAutomaticSnapshots = (party: PartyCore, clock: TimeframeClock, store: SnapshotStore, interval: number) => clock.update.on(async timeframe => {
+  const totalMessages = timeframe.totalMessages();
+  if (totalMessages > 0 && totalMessages % interval === 0) {
+    log(`Saving snapshot of ${party.key.humanize()}...`);
+    try {
+      const snapshot = party.createSnapshot();
+      await store.save(snapshot);
+    } catch (err: any) {
+      console.error('Failed to save snapshot');
+      console.error(err);
     }
-  });
-}
+  }
+});

package/src/snapshots/snapshot-store.test.ts

@@ -7,15 +7,15 @@ import { it as test } from 'mocha';
 
 import { createId, createKeyPair, PublicKey } from '@dxos/crypto';
 import { PartySnapshot } from '@dxos/echo-protocol';
+import { createStorage, StorageType } from '@dxos/random-access-multi-storage';
 
-import { createRamStorage } from '../util';
 import { SnapshotStore } from './snapshot-store';
 
 const createPublicKey = () => PublicKey.from(createKeyPair().publicKey);
 
 describe('SnapshotStore', () => {
   test('in-memory', async () => {
-    const store = new SnapshotStore(createRamStorage());
+    const store = new SnapshotStore(createStorage('', StorageType.RAM).directory('snapshots'));
 
     const key1 = createPublicKey();
     const key2 = createPublicKey();

package/src/snapshots/snapshot-store.ts

@@ -7,10 +7,9 @@ import debug from 'debug';
 
 import { keyToString } from '@dxos/crypto';
 import { schema, PartyKey, PartySnapshot } from '@dxos/echo-protocol';
-import { IStorage } from '@dxos/random-access-multi-storage';
+import { Directory } from '@dxos/random-access-multi-storage';
 
 const log = debug('dxos:snapshot-store');
-
 /**
  * Stores party snapshots. Takes any `random-access-storage` compatible backend.
  *
@@ -18,11 +17,11 @@ const log = debug('dxos:snapshot-store');
  */
 export class SnapshotStore {
   constructor (
-    private readonly _storage: IStorage
+    private readonly _directory: Directory
   ) {}
 
   async load (partyKey: PartyKey): Promise<PartySnapshot | undefined> {
-    const file = this._storage.createOrOpen(partyKey.toHex());
+    const file = this._directory.createOrOpen(partyKey.toHex());
 
     try {
       const { size } = await file.stat();
@@ -45,7 +44,7 @@ export class SnapshotStore {
 
   async save (snapshot: PartySnapshot) {
     assert(snapshot.partyKey);
-    const file = this._storage.createOrOpen(keyToString(snapshot.partyKey), { truncate: true, size: 0 });
+    const file = this._directory.createOrOpen(keyToString(snapshot.partyKey), { truncate: true, size: 0 });
 
     try {
       const data = schema.getCodecForType('dxos.echo.snapshot.PartySnapshot').encode(snapshot);
@@ -60,6 +59,6 @@ export class SnapshotStore {
    */
   async clear () {
     log('Clearing all snapshots..');
-    await this._storage.destroy();
+    await this._directory.destroy();
   }
 }

package/src/testing/benchmark.test.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { ObjectModel } from '@dxos/object-model';
+
+import { ECHO } from '../echo';
+
+const ITEMS = 100;
+const MUTATIONS = 1000;
+
+it.skip('Database benchmark', async () => {
+  const echo = new ECHO({ snapshots: false });
+  await echo.open();
+  await echo.halo.createProfile();
+  const party = await echo.createParty();
+
+  const start = Date.now();
+  for (let i = 0; i < ITEMS; i++) {
+    const item = await party.database.createItem({ model: ObjectModel, type: 'test:item' });
+
+    for (let j = 0; j < MUTATIONS; j++) {
+      await item.model.set(`key${j % 100}`, `value-${j}`);
+    }
+
+    console.log(`${i * MUTATIONS}/${ITEMS * MUTATIONS} ${((Date.now() - start) / ((i + 1) * MUTATIONS / 1000)).toFixed(1)} µs/mut ${((i + 1) * MUTATIONS / (Date.now() - start) * 1000).toFixed(1)} mut/s`);
+  }
+
+  await echo.close();
+});

package/src/testing/testing-factories.ts

@@ -22,10 +22,10 @@ export type TestPeer = Awaited<ReturnType<typeof createTestInstance>>;
 
 export type WithTestMeta<T> = T & { testMeta: TestPeer }
 
-function addTestMeta<T> (obj: T, meta: TestPeer): WithTestMeta<T> {
+const addTestMeta = <T>(obj: T, meta: TestPeer): WithTestMeta<T> => {
   (obj as any).testMeta = meta;
   return obj as any;
-}
+};
 
 /**
  * Creates a number of test ECHO instances and a party that's shared between all of them.

package/src/testing/testing.ts

@@ -5,12 +5,11 @@
 import debug from 'debug';
 
 import { NetworkManagerOptions } from '@dxos/network-manager';
-import { IStorage } from '@dxos/random-access-multi-storage';
+import { Storage, createStorage, StorageType } from '@dxos/random-access-multi-storage';
 import { jsonReplacer } from '@dxos/util';
 
 import { ECHO } from '../echo';
 import { DataParty } from '../parties';
-import { createRamStorage } from '../util';
 
 export const log = debug('dxos:echo-db:testing');
 
@@ -21,13 +20,12 @@ export const messageLogger = (tag: string) => (message: any) => {
 export interface TestOptions {
   verboseLogging?: boolean
   initialize?: boolean
-  storage?: any
+  storage?: Storage
   keyStorage?: any
   networkManagerOptions?: NetworkManagerOptions
   // TODO(burdon): Group properties by hierarchical object.
   snapshots?: boolean
   snapshotInterval?: number
-  snapshotStorage?: IStorage
 }
 
 /**
@@ -36,17 +34,15 @@ export interface TestOptions {
 export const createTestInstance = async ({
   verboseLogging = false,
   initialize = false,
-  storage = createRamStorage(),
+  storage = createStorage('', StorageType.RAM),
   keyStorage = undefined,
   networkManagerOptions,
-  snapshotStorage = createRamStorage(),
   snapshots = true,
   snapshotInterval
 }: TestOptions = {}) => {
   const echo = new ECHO({
-    feedStorage: storage,
+    storage,
     keyStorage,
-    snapshotStorage,
     snapshotInterval,
     snapshots,
     networkManagerOptions,

package/dist/src/util/index.d.ts

@@ -1,2 +0,0 @@
-export * from './persistant-ram-storage';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/util/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/util/index.ts"],"names":[],"mappings":"AAIA,cAAc,0BAA0B,CAAC"}

package/dist/src/util/index.js

@@ -1,17 +0,0 @@
-"use strict";
-//
-// Copyright 2020 DXOS.org
-//
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./persistant-ram-storage"), exports);
-//# sourceMappingURL=index.js.map

package/dist/src/util/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/util/index.ts"],"names":[],"mappings":";AAAA,EAAE;AACF,0BAA0B;AAC1B,EAAE;;;;;;;;;;;;AAEF,2DAAyC"}

package/dist/src/util/persistant-ram-storage.d.ts

@@ -1,6 +0,0 @@
-import { IStorage } from '@dxos/random-access-multi-storage';
-/**
- * A wrapper around RAM storage that preserves file data when closing and re-opening files.
- */
-export declare function createRamStorage(): IStorage;
-//# sourceMappingURL=persistant-ram-storage.d.ts.map

package/dist/src/util/persistant-ram-storage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"persistant-ram-storage.d.ts","sourceRoot":"","sources":["../../../src/util/persistant-ram-storage.ts"],"names":[],"mappings":"AAIA,OAAO,EAAoC,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AAE/F;;GAEG;AAEH,wBAAgB,gBAAgB,IAAK,QAAQ,CAsB5C"}

package/dist/src/util/persistant-ram-storage.js

@@ -1,32 +0,0 @@
-"use strict";
-//
-// Copyright 2020 DXOS.org
-//
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRamStorage = void 0;
-const random_access_multi_storage_1 = require("@dxos/random-access-multi-storage");
-/**
- * A wrapper around RAM storage that preserves file data when closing and re-opening files.
- */
-// TODO(burdon): Factor out?
-function createRamStorage() {
-    const root = 'snapshots';
-    const storage = (0, random_access_multi_storage_1.createStorage)(root, random_access_multi_storage_1.StorageType.RAM);
-    const files = new Map();
-    const fn = {};
-    fn.createOrOpen = (name) => {
-        if (files.has(name)) {
-            return files.get(name);
-        }
-        const file = storage.createOrOpen(name);
-        file.close = (cb) => cb === null || cb === void 0 ? void 0 : cb(null); // Fix.
-        files.set(name, file);
-        return file;
-    };
-    fn.root = root;
-    fn.type = storage.type;
-    fn.destroy = storage.destroy.bind(storage);
-    return fn;
-}
-exports.createRamStorage = createRamStorage;
-//# sourceMappingURL=persistant-ram-storage.js.map