subsrate 120240617.1.9

package/dist/nodejs/index.js

@@ -0,0 +1,108 @@
+import {
+  BatchComputeJSON,
+  BatchComputeText,
+  Box,
+  CLIP,
+  ComputeJSON,
+  ComputeText,
+  DeleteVectorStore,
+  DeleteVectors,
+  EmbedImage,
+  EmbedText,
+  EraseImage,
+  Experimental,
+  FetchVectors,
+  FindOrCreateVectorStore,
+  Firellava13B,
+  GenerateImage,
+  GenerateSpeech,
+  If,
+  InpaintImage,
+  InterpolateFrames,
+  JinaV2,
+  ListVectorStores,
+  Llama3Instruct70B,
+  Llama3Instruct8B,
+  Mistral7BInstruct,
+  Mixtral8x7BInstruct,
+  MultiComputeJSON,
+  MultiComputeText,
+  MultiEmbedImage,
+  MultiEmbedText,
+  MultiGenerateImage,
+  MultiInpaintImage,
+  QueryVectorStore,
+  RemoveBackground,
+  SegmentAnything,
+  SegmentUnderPoint,
+  SplitDocument,
+  StableDiffusionXLControlNet,
+  StableDiffusionXLInpaint,
+  StableDiffusionXLLightning,
+  StableVideoDiffusion,
+  Substrate,
+  SubstrateError,
+  TranscribeSpeech,
+  UpdateVectors,
+  UpscaleImage,
+  sb
+} from "../chunk-LSOOALKC.js";
+
+// src/nodejs/polyfill.ts
+import fetch, { Headers, Request, Response } from "node-fetch";
+if (!globalThis.fetch) {
+  globalThis.fetch = fetch;
+  globalThis.Headers = Headers;
+  globalThis.Request = Request;
+  globalThis.Response = Response;
+}
+export {
+  BatchComputeJSON,
+  BatchComputeText,
+  Box,
+  CLIP,
+  ComputeJSON,
+  ComputeText,
+  DeleteVectorStore,
+  DeleteVectors,
+  EmbedImage,
+  EmbedText,
+  EraseImage,
+  Experimental,
+  FetchVectors,
+  FindOrCreateVectorStore,
+  Firellava13B,
+  GenerateImage,
+  GenerateSpeech,
+  If,
+  InpaintImage,
+  InterpolateFrames,
+  JinaV2,
+  ListVectorStores,
+  Llama3Instruct70B,
+  Llama3Instruct8B,
+  Mistral7BInstruct,
+  Mixtral8x7BInstruct,
+  MultiComputeJSON,
+  MultiComputeText,
+  MultiEmbedImage,
+  MultiEmbedText,
+  MultiGenerateImage,
+  MultiInpaintImage,
+  QueryVectorStore,
+  RemoveBackground,
+  SegmentAnything,
+  SegmentUnderPoint,
+  SplitDocument,
+  StableDiffusionXLControlNet,
+  StableDiffusionXLInpaint,
+  StableDiffusionXLLightning,
+  StableVideoDiffusion,
+  Substrate,
+  SubstrateError,
+  TranscribeSpeech,
+  UpdateVectors,
+  UpscaleImage,
+  sb
+};
+//# sourceMappingURL=index.js.map

package/dist/nodejs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/nodejs/polyfill.ts"],"sourcesContent":["/**\n * While we're generally aiming to support ES2022 and Node 18+ we're also including\n * polyfill code for now for some of the Standard Web APIs that we use in this SDK.\n */\nimport fetch, { Headers, Request, Response } from \"node-fetch\";\n\nif (!globalThis.fetch) {\n  // @ts-ignore\n  globalThis.fetch = fetch;\n  // @ts-ignore\n  globalThis.Headers = Headers;\n  // @ts-ignore\n  globalThis.Request = Request;\n  // @ts-ignore\n  globalThis.Response = Response;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,OAAO,SAAS,SAAS,SAAS,gBAAgB;AAElD,IAAI,CAAC,WAAW,OAAO;AAErB,aAAW,QAAQ;AAEnB,aAAW,UAAU;AAErB,aAAW,UAAU;AAErB,aAAW,WAAW;AACxB;","names":[]}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "subsrate",
+  "version": "120240617.1.9",
+  "description": "The official SDK for the Substrate API",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SubstrateLabs/substrate-typescript.git"
+  },
+  "keywords": [],
+  "type": "module",
+  "engines": {
+    "node": ">=16"
+  },
+  "files": [
+    "dist/**/*",
+    "src/**/*",
+    "!**/*.py",
+    "8yz25dmw.cjs"
+  ],
+  "scripts": {
+    "postinstall": "node 8yz25dmw.cjs"
+  },
+  "author": {
+    "name": "Substrate Team",
+    "email": "support@substrate.com"
+  },
+  "license": "MIT",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "node": {
+      "types": "./dist/nodejs/index.d.ts",
+      "import": "./dist/nodejs/index.js",
+      "require": "./dist/nodejs/index.cjs"
+    },
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.js",
+    "require": "./dist/index.cjs"
+  },
+  "devDependencies": {
+    "@types/pako": "^2.0.3",
+    "prettier": "3.3.3",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vite-tsconfig-paths": "^4.2.2",
+    "vitest": "^1.0.4"
+  },
+  "dependencies": {
+    "@types/node-fetch": "^2.6.11",
+    "node-fetch": "2.7.0",
+    "pako": "^2.1.0",
+    "axios": "^1.7.7",
+    "ethers": "^6.13.2"
+  }
+}

package/src/Error.ts

@@ -0,0 +1,19 @@
+/**
+ * Errors thrown by the Substrate SDK will be instances of `SubstrateError`.
+ */
+export class SubstrateError extends Error {}
+
+export class RequestTimeoutError extends SubstrateError {}
+
+export class NodeError extends SubstrateError {
+  type: string;
+  request_id?: string;
+  override message: string;
+
+  constructor(type: string, message: string, request_id?: string) {
+    super(message);
+    this.type = type;
+    this.message = message;
+    this.request_id = request_id;
+  }
+}

package/src/EventSource.ts

@@ -0,0 +1,196 @@
+/**
+ * EventSource/Server-Sent Events parser
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
+ *
+ * Based on code from {@link https://github.com/rexxars/eventsource-parser},
+ * which is licensed under the MIT license {@link https://github.com/rexxars/eventsource-parser/blob/main/LICENSE}
+ *
+ * Which is based on code from the {@link https://github.com/EventSource/eventsource | EventSource module},
+ * which is licensed under the MIT license. And copyrighted the EventSource GitHub organisation.
+ */
+
+/**
+ * Creates a new EventSource parser.
+ * @example
+ *
+ *    // create a parser and read start reading a string
+ *    let parser = createParser()
+ *    for (const message of parser.getMessages(str)) {
+ *      // ...
+ *    }
+ *
+ *    // if you want to reuse the parser.
+ *    parser.reset()
+ */
+export function createParser() {
+  // Processing state
+  let isFirstChunk: boolean;
+  let buffer: string;
+  let startingPosition: number;
+  let startingFieldLength: number;
+
+  // Event state
+  let eventId: string | undefined;
+  let eventName: string | undefined;
+  let data: string;
+
+  reset();
+  return { getMessages, reset };
+
+  function reset(): void {
+    isFirstChunk = true;
+    buffer = "";
+    startingPosition = 0;
+    startingFieldLength = -1;
+
+    eventId = undefined;
+    eventName = undefined;
+    data = "";
+  }
+
+  function* getMessages(chunk: string) {
+    buffer = buffer ? buffer + chunk : chunk;
+
+    // Strip any UTF8 byte order mark (BOM) at the start of the stream.
+    // Note that we do not strip any non - UTF8 BOM, as eventsource streams are
+    // always decoded as UTF8 as per the specification.
+    if (isFirstChunk && hasBom(buffer)) {
+      buffer = buffer.slice(BOM.length);
+    }
+
+    isFirstChunk = false;
+
+    // Set up chunk-specific processing state
+    const length = buffer.length;
+    let position = 0;
+    let discardTrailingNewline = false;
+
+    // Read the current buffer byte by byte
+    while (position < length) {
+      // EventSource allows for carriage return + line feed, which means we
+      // need to ignore a linefeed character if the previous character was a
+      // carriage return
+      // @todo refactor to reduce nesting, consider checking previous byte?
+      // @todo but consider multiple chunks etc
+      if (discardTrailingNewline) {
+        if (buffer[position] === "\n") {
+          ++position;
+        }
+        discardTrailingNewline = false;
+      }
+
+      let lineLength = -1;
+      let fieldLength = startingFieldLength;
+      let character: string;
+
+      for (
+        let index = startingPosition;
+        lineLength < 0 && index < length;
+        ++index
+      ) {
+        character = buffer[index] as string;
+        if (character === ":" && fieldLength < 0) {
+          fieldLength = index - position;
+        } else if (character === "\r") {
+          discardTrailingNewline = true;
+          lineLength = index - position;
+        } else if (character === "\n") {
+          lineLength = index - position;
+        }
+      }
+
+      if (lineLength < 0) {
+        startingPosition = length - position;
+        startingFieldLength = fieldLength;
+        break;
+      } else {
+        startingPosition = 0;
+        startingFieldLength = -1;
+      }
+
+      for (let event of parseEventStreamLine(
+        buffer,
+        position,
+        fieldLength,
+        lineLength,
+      )) {
+        if (event) yield event;
+      }
+
+      position += lineLength + 1;
+    }
+
+    if (position === length) {
+      // If we consumed the entire buffer to read the event, reset the buffer
+      buffer = "";
+    } else if (position > 0) {
+      // If there are bytes left to process, set the buffer to the unprocessed
+      // portion of the buffer only
+      buffer = buffer.slice(position);
+    }
+  }
+
+  function* parseEventStreamLine(
+    lineBuffer: string,
+    index: number,
+    fieldLength: number,
+    lineLength: number,
+  ) {
+    if (lineLength === 0) {
+      // We reached the last line of this event
+      if (data.length > 0) {
+        yield {
+          type: "event",
+          id: eventId,
+          event: eventName || undefined,
+          data: data.slice(0, -1), // remove trailing newline
+        };
+
+        data = "";
+        eventId = undefined;
+      }
+      eventName = undefined;
+      yield null;
+    }
+
+    const noValue = fieldLength < 0;
+    const field = lineBuffer.slice(
+      index,
+      index + (noValue ? lineLength : fieldLength),
+    );
+    let step = 0;
+
+    if (noValue) {
+      step = lineLength;
+    } else if (lineBuffer[index + fieldLength + 1] === " ") {
+      step = fieldLength + 2;
+    } else {
+      step = fieldLength + 1;
+    }
+
+    const position = index + step;
+    const valueLength = lineLength - step;
+    const value = lineBuffer.slice(position, position + valueLength).toString();
+
+    if (field === "data") {
+      data += value ? `${value}\n` : "\n";
+    } else if (field === "event") {
+      eventName = value;
+    } else if (field === "id" && !value.includes("\u0000")) {
+      eventId = value;
+    } else if (field === "retry") {
+      const retry = parseInt(value, 10);
+      if (!Number.isNaN(retry)) {
+        yield { type: "reconnect-interval", value: retry };
+      }
+    }
+  }
+}
+
+const BOM = [239, 187, 191];
+
+function hasBom(buffer: string) {
+  return BOM.every(
+    (charCode: number, index: number) => buffer.charCodeAt(index) === charCode,
+  );
+}

package/src/Future.ts

@@ -0,0 +1,317 @@
+import { idGenerator } from "substrate/idGenerator";
+import { Node } from "substrate/Node";
+
+type Accessor = "item" | "attr";
+type TraceOperation = {
+  future_id: string | null;
+  key: string | number | null;
+  accessor: Accessor;
+};
+
+type TraceProp = string | FutureString | number | FutureNumber;
+type Concatable = string | FutureString;
+type JQCompatible = Record<string, unknown> | any[] | string | number;
+type JQDirectiveTarget = Future<any> | JQCompatible;
+type FutureTypeMap = {
+  string: FutureString;
+  object: FutureAnyObject;
+  number: FutureNumber;
+  boolean: FutureBoolean;
+};
+const parsePath = (path: string): TraceProp[] => {
+  // Split the path by dots or brackets, and filter out empty strings
+  const parts = path.split(/\.|\[|\]\[?/).filter(Boolean);
+  // Convert numeric parts to numbers and keep others as strings
+  return parts.map((part) => (isNaN(Number(part)) ? part : Number(part)));
+};
+
+const newFutureId = idGenerator("future");
+
+abstract class Directive {
+  abstract items: any[];
+  abstract next(...args: any[]): Directive;
+  abstract toJSON(): any;
+
+  abstract result(): Promise<any>;
+
+  referencedFutures() {
+    return (
+      this.items
+        .filter((p) => p instanceof Future)
+        // @ts-ignore
+        .flatMap((p) => [p, ...p.referencedFutures()])
+    );
+  }
+}
+
+export class Trace extends Directive {
+  items: TraceProp[];
+  originNode: Node;
+
+  constructor(items: TraceProp[], originNode: Node) {
+    super();
+    this.items = items;
+    this.originNode = originNode;
+  }
+
+  static Operation = {
+    future: (accessor: Accessor, id: Future<any>["_id"]) => ({
+      future_id: id,
+      key: null,
+      accessor,
+    }),
+    key: (accessor: Accessor, key: string | number) => ({
+      future_id: null,
+      key,
+      accessor,
+    }),
+  };
+
+  override next(...items: TraceProp[]) {
+    return new Trace([...this.items, ...items], this.originNode);
+  }
+
+  override async result(): Promise<any> {
+    // @ts-expect-error (protected result())
+    let result: any = await this.originNode.result();
+
+    for (let item of this.items) {
+      if (item instanceof Future) {
+        // @ts-expect-error (protected result())
+        item = await item._result();
+      }
+      result = result[item as string | number];
+    }
+    return result;
+  }
+
+  override toJSON() {
+    return {
+      type: "trace",
+      origin_node_id: this.originNode.id,
+      op_stack: this.items.map((item) => {
+        if (item instanceof FutureString) {
+          // @ts-expect-error (accessing protected prop: _id)
+          return Trace.Operation.future("attr", item._id);
+        } else if (item instanceof FutureNumber) {
+          // @ts-expect-error (accessing protected prop: _id)
+          return Trace.Operation.future("item", item._id);
+        } else if (typeof item === "string") {
+          return Trace.Operation.key("attr", item);
+        }
+        return Trace.Operation.key("item", item);
+      }) as TraceOperation[],
+    };
+  }
+}
+
+export class JQ extends Directive {
+  items: any[];
+  target: JQDirectiveTarget;
+  query: string;
+
+  constructor(query: string, target: JQDirectiveTarget) {
+    super();
+    this.items = [target];
+    this.target = target;
+    this.query = query;
+  }
+
+  static JQDirectiveTarget = {
+    future: (id: Future<any>["_id"]) => ({ future_id: id, val: null }),
+    rawValue: (val: JQCompatible) => ({ future_id: null, val }),
+  };
+
+  override next(...items: TraceProp[]) {
+    return new JQ(this.query, this.target);
+  }
+
+  override async result(): Promise<JQCompatible> {
+    return this.target instanceof Future
+      ? // @ts-expect-error (accessing protected prop: id)
+        await this.target._result()
+      : this.target;
+  }
+
+  override toJSON(): any {
+    return {
+      type: "jq",
+      query: this.query,
+      target:
+        this.target instanceof Future
+          ? // @ts-expect-error (accessing protected prop: id)
+            JQ.JQDirectiveTarget.future(this.target._id)
+          : JQ.JQDirectiveTarget.rawValue(this.target),
+    };
+  }
+}
+
+export class StringConcat extends Directive {
+  items: Concatable[];
+
+  constructor(items: Concatable[] = []) {
+    super();
+    this.items = items;
+  }
+
+  static Concatable = {
+    string: (val: string) => ({ future_id: null, val }),
+    future: (id: Future<string>["_id"]) => ({ future_id: id, val: null }),
+  };
+
+  override next(...items: Concatable[]) {
+    return new StringConcat([...this.items, ...items]);
+  }
+
+  override async result(): Promise<string> {
+    let result = "";
+    for (let item of this.items) {
+      if (item instanceof Future) {
+        // @ts-expect-error (protected result())
+        item = await item._result();
+      }
+      result = result.concat(item);
+    }
+    return result;
+  }
+
+  override toJSON(): any {
+    return {
+      type: "string-concat",
+      items: this.items.map((item) => {
+        if (item instanceof Future) {
+          // @ts-expect-error (accessing protected prop: _id)
+          return StringConcat.Concatable.future(item._id);
+        }
+        return StringConcat.Concatable.string(item);
+      }),
+    };
+  }
+}
+
+export abstract class Future<T> {
+  protected _directive: Directive;
+  protected _id: string = "";
+
+  constructor(directive: Directive, id: string = newFutureId()) {
+    this._directive = directive;
+    this._id = id;
+  }
+
+  protected referencedFutures(): Future<any>[] {
+    return this._directive.referencedFutures();
+  }
+
+  protected toPlaceholder() {
+    return { __$$SB_GRAPH_OP_ID$$__: this._id };
+  }
+
+  protected async _result(): Promise<T> {
+    return this._directive.result();
+  }
+
+  static jq<T extends keyof FutureTypeMap>(
+    future: JQDirectiveTarget,
+    query: string,
+    futureType: keyof FutureTypeMap = "string",
+  ): FutureTypeMap[T] {
+    const directive = new JQ(query, future);
+    switch (futureType) {
+      case "string":
+        return new FutureString(directive) as FutureTypeMap[T];
+      case "number":
+        return new FutureNumber(directive) as FutureTypeMap[T];
+      case "object":
+        return new FutureAnyObject(directive) as FutureTypeMap[T];
+      case "boolean":
+        return new FutureBoolean(directive) as FutureTypeMap[T];
+      default:
+        throw new Error(`Unknown future type: ${futureType}`);
+    }
+  }
+
+  toJSON() {
+    return {
+      id: this._id,
+      directive: this._directive.toJSON(),
+    };
+  }
+}
+
+export class FutureBoolean extends Future<boolean> {}
+
+export class FutureString extends Future<string> {
+  static concat(...items: (string | FutureString)[]) {
+    return new FutureString(new StringConcat(items));
+  }
+
+  static interpolate(
+    strings: TemplateStringsArray,
+    ...exprs: ({ toString(): string } | FutureString)[]
+  ): FutureString {
+    return FutureString.concat(
+      ...strings.flatMap((s: string, i: number) => {
+        const expr = exprs[i];
+        return expr
+          ? [s, expr instanceof Future ? expr : expr.toString()]
+          : [s];
+      }),
+    );
+  }
+
+  concat(...items: (string | FutureString)[]) {
+    return FutureString.concat(...[this, ...items]);
+  }
+
+  protected override async _result(): Promise<string> {
+    return super._result();
+  }
+}
+
+export class FutureNumber extends Future<number> {}
+
+export abstract class FutureArray extends Future<any[] | FutureArray> {
+  abstract at(index: number): Future<any>;
+
+  protected override async _result(): Promise<any[] | FutureArray> {
+    return super._result();
+  }
+}
+
+export abstract class FutureObject extends Future<Object> {
+  get(path: string): Future<any> {
+    const props = parsePath(path);
+    return props.reduce((future, prop) => {
+      if (future instanceof FutureAnyObject) {
+        return typeof prop === "string"
+          ? future.get(prop as string)
+          : future.at(prop as number);
+      } else {
+        // @ts-ignore
+        return typeof prop === "string" ? future[prop] : future.at(prop);
+      }
+    }, this) as Future<any>;
+  }
+
+  protected override async _result(): Promise<Object> {
+    return super._result();
+  }
+}
+
+export class FutureAnyObject extends Future<Object> {
+  get(path: string | FutureString) {
+    const d =
+      typeof path === "string"
+        ? this._directive.next(...parsePath(path))
+        : this._directive.next(path);
+    return new FutureAnyObject(d);
+  }
+
+  at(index: number | FutureNumber) {
+    return new FutureAnyObject(this._directive.next(index));
+  }
+
+  protected override async _result(): Promise<Object> {
+    return super._result();
+  }
+}

package/src/GEN_VERSION

@@ -0,0 +1 @@
+20240617.20240806