Function prepareRecorderKitMakers

  • prepareRecorderKitMakers(baggage, marshaller): {
        makeDurablePublishKit: ((...args) => {
            publisher: {
                fail(reason): void;
                finish(finalValue): void;
                publish(value): void;
            };
            subscriber: {
                getUpdateSince(updateCount): any;
                subscribeAfter(publishCount?): Promise<any>;
            };
        } & RemotableBrand<{}, {
            publisher: {
                fail(reason): void;
                finish(finalValue): void;
                publish(value): void;
            };
            subscriber: {
                getUpdateSince(updateCount): any;
                subscribeAfter(publishCount?): Promise<any>;
            };
        }>);
        makeERecorderKit: (<T>(storageNodeP, valueShape?) => EventualRecorderKit<T>);
        makeRecorder: ((...args) => {
            getStorageNode(): DataOnly<StorageNode> & RemotableBrand<DataOnly<StorageNode>, StorageNode>;
            getStoragePath(): Promise<string>;
            write(value): Promise<void>;
            writeFinal(value): Promise<void>;
        } & RemotableBrand<{}, {
            getStorageNode(): DataOnly<StorageNode> & RemotableBrand<DataOnly<StorageNode>, StorageNode>;
            getStoragePath(): Promise<string>;
            write(value): Promise<void>;
            writeFinal(value): Promise<void>;
        }>);
        makeRecorderKit: (<T>(storageNode, valueShape?) => RecorderKit<T>);
    }

  • Convenience wrapper for DurablePublishKit and Recorder kinds.

    NB: this defines two durable kinds. Must be called at most once per baggage.

    makeRecorderKit is suitable for making a durable RecorderKit which can be held in Exo state. makeERecorderKit is for closures that must return a subscriber synchronously but can defer the recorder.

    Parameters

    • baggage: Baggage
    • marshaller: ERef<Marshaller<unknown>>

    Returns {
        makeDurablePublishKit: ((...args) => {
            publisher: {
                fail(reason): void;
                finish(finalValue): void;
                publish(value): void;
            };
            subscriber: {
                getUpdateSince(updateCount): any;
                subscribeAfter(publishCount?): Promise<any>;
            };
        } & RemotableBrand<{}, {
            publisher: {
                fail(reason): void;
                finish(finalValue): void;
                publish(value): void;
            };
            subscriber: {
                getUpdateSince(updateCount): any;
                subscribeAfter(publishCount?): Promise<any>;
            };
        }>);
        makeERecorderKit: (<T>(storageNodeP, valueShape?) => EventualRecorderKit<T>);
        makeRecorder: ((...args) => {
            getStorageNode(): DataOnly<StorageNode> & RemotableBrand<DataOnly<StorageNode>, StorageNode>;
            getStoragePath(): Promise<string>;
            write(value): Promise<void>;
            writeFinal(value): Promise<void>;
        } & RemotableBrand<{}, {
            getStorageNode(): DataOnly<StorageNode> & RemotableBrand<DataOnly<StorageNode>, StorageNode>;
            getStoragePath(): Promise<string>;
            write(value): Promise<void>;
            writeFinal(value): Promise<void>;
        }>);
        makeRecorderKit: (<T>(storageNode, valueShape?) => RecorderKit<T>);
    }

    • makeDurablePublishKit: ((...args) => {
          publisher: {
              fail(reason): void;
              finish(finalValue): void;
              publish(value): void;
          };
          subscriber: {
              getUpdateSince(updateCount): any;
              subscribeAfter(publishCount?): Promise<any>;
          };
      } & RemotableBrand<{}, {
          publisher: {
              fail(reason): void;
              finish(finalValue): void;
              publish(value): void;
          };
          subscriber: {
              getUpdateSince(updateCount): any;
              subscribeAfter(publishCount?): Promise<any>;
          };
      }>)
        • (...args): {
              publisher: {
                  fail(reason): void;
                  finish(finalValue): void;
                  publish(value): void;
              };
              subscriber: {
                  getUpdateSince(updateCount): any;
                  subscribeAfter(publishCount?): Promise<any>;
              };
          } & RemotableBrand<{}, {
              publisher: {
                  fail(reason): void;
                  finish(finalValue): void;
                  publish(value): void;
              };
              subscriber: {
                  getUpdateSince(updateCount): any;
                  subscribeAfter(publishCount?): Promise<any>;
              };
          }>

        • Parameters

          • Rest ...args: [options: {
                valueDurability: undefined | "mandatory";
            }]

          Returns {
              publisher: {
                  fail(reason): void;
                  finish(finalValue): void;
                  publish(value): void;
              };
              subscriber: {
                  getUpdateSince(updateCount): any;
                  subscribeAfter(publishCount?): Promise<any>;
              };
          } & RemotableBrand<{}, {
              publisher: {
                  fail(reason): void;
                  finish(finalValue): void;
                  publish(value): void;
              };
              subscriber: {
                  getUpdateSince(updateCount): any;
                  subscribeAfter(publishCount?): Promise<any>;
              };
          }>

    • makeERecorderKit: (<T>(storageNodeP, valueShape?) => EventualRecorderKit<T>)
    • makeRecorder: ((...args) => {
          getStorageNode(): DataOnly<StorageNode> & RemotableBrand<DataOnly<StorageNode>, StorageNode>;
          getStoragePath(): Promise<string>;
          write(value): Promise<void>;
          writeFinal(value): Promise<void>;
      } & RemotableBrand<{}, {
          getStorageNode(): DataOnly<StorageNode> & RemotableBrand<DataOnly<StorageNode>, StorageNode>;
          getStoragePath(): Promise<string>;
          write(value): Promise<void>;
          writeFinal(value): Promise<void>;
      }>)
        • (...args): {
              getStorageNode(): DataOnly<StorageNode> & RemotableBrand<DataOnly<StorageNode>, StorageNode>;
              getStoragePath(): Promise<string>;
              write(value): Promise<void>;
              writeFinal(value): Promise<void>;
          } & RemotableBrand<{}, {
              getStorageNode(): DataOnly<StorageNode> & RemotableBrand<DataOnly<StorageNode>, StorageNode>;
              getStoragePath(): Promise<string>;
              write(value): Promise<void>;
              writeFinal(value): Promise<void>;
          }>

        • Parameters

          • Rest ...args: [publisher: Publisher<unknown>, storageNode: DataOnly<StorageNode> & RemotableBrand<DataOnly<StorageNode>, StorageNode>, valueShape: TypedMatcher<unknown>]

          Returns {
              getStorageNode(): DataOnly<StorageNode> & RemotableBrand<DataOnly<StorageNode>, StorageNode>;
              getStoragePath(): Promise<string>;
              write(value): Promise<void>;
              writeFinal(value): Promise<void>;
          } & RemotableBrand<{}, {
              getStorageNode(): DataOnly<StorageNode> & RemotableBrand<DataOnly<StorageNode>, StorageNode>;
              getStoragePath(): Promise<string>;
              write(value): Promise<void>;
              writeFinal(value): Promise<void>;
          }>

    • makeRecorderKit: (<T>(storageNode, valueShape?) => RecorderKit<T>)
        • <T>(storageNode, valueShape?): RecorderKit<T>

        • Type Parameters

          • T

          Parameters

          • storageNode: StorageNode | DataOnly<StorageNode> & RemotableBrand<DataOnly<StorageNode>, StorageNode>
          • Optional valueShape: TypedMatcher<T>

          Returns RecorderKit<T>

Settings

Member Visibility

Theme

Generated using TypeDoc