@depup/react-native-worklets 0.12.2-depup.0 → 0.13.0-depup.0

package/src/networking/Blob.ts

@@ -0,0 +1,74 @@
+'use strict';
+
+import { toArrayBuffer } from './bytes';
+import { stripUtf8Bom, utf8Decode, utf8Encode } from './utf8';
+
+type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob;
+
+export class Blob {
+  readonly type: string;
+
+  private bytes: Uint8Array;
+
+  constructor(parts: BlobPart[] = [], options: { type?: string } = {}) {
+    const chunks = parts.map(toUint8Array);
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const bytes = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.length;
+    }
+    this.bytes = bytes;
+    this.type = String(options.type ?? '').toLowerCase();
+  }
+
+  get size(): number {
+    return this.bytes.byteLength;
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'Blob';
+  }
+
+  slice(start = 0, end = this.size, contentType = ''): Blob {
+    const size = this.size;
+    const relativeStart =
+      start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
+    const relativeEnd = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
+    const span = Math.max(relativeEnd - relativeStart, 0);
+    const blob = new Blob([], { type: contentType });
+    blob.bytes = this.bytes.slice(relativeStart, relativeStart + span);
+    return blob;
+  }
+
+  arrayBuffer(): Promise<ArrayBuffer> {
+    return Promise.resolve(toArrayBuffer(this.bytes));
+  }
+
+  text(): Promise<string> {
+    return Promise.resolve(utf8Decode(stripUtf8Bom(this.bytes)));
+  }
+
+  __getBytes(): Uint8Array {
+    return this.bytes;
+  }
+}
+
+function toUint8Array(part: BlobPart): Uint8Array {
+  if (typeof part === 'string') {
+    return utf8Encode(part);
+  }
+  if (part instanceof Blob) {
+    return part.__getBytes();
+  }
+  if (ArrayBuffer.isView(part)) {
+    return new Uint8Array(
+      part.buffer.slice(part.byteOffset, part.byteOffset + part.byteLength)
+    );
+  }
+  if (part instanceof ArrayBuffer) {
+    return new Uint8Array(part.slice(0));
+  }
+  return utf8Encode(String(part));
+}

package/src/networking/DOMException.ts

@@ -0,0 +1,37 @@
+'use strict';
+
+const LEGACY_CODES: Record<string, number> = {
+  IndexSizeError: 1,
+  HierarchyRequestError: 3,
+  WrongDocumentError: 4,
+  InvalidCharacterError: 5,
+  NoModificationAllowedError: 7,
+  NotFoundError: 8,
+  NotSupportedError: 9,
+  InUseAttributeError: 10,
+  InvalidStateError: 11,
+  SyntaxError: 12,
+  InvalidModificationError: 13,
+  NamespaceError: 14,
+  InvalidAccessError: 15,
+  TypeMismatchError: 17,
+  SecurityError: 18,
+  NetworkError: 19,
+  AbortError: 20,
+  URLMismatchError: 21,
+  QuotaExceededError: 22,
+  TimeoutError: 23,
+  InvalidNodeTypeError: 24,
+  DataCloneError: 25,
+};
+
+export class DOMException extends Error {
+  readonly code: number;
+
+  constructor(message = '', name = 'Error') {
+    super(message);
+    Object.setPrototypeOf(this, DOMException.prototype);
+    this.name = name;
+    this.code = LEGACY_CODES[name] ?? 0;
+  }
+}

package/src/networking/FileReader.ts

@@ -0,0 +1,99 @@
+'use strict';
+
+import type { Blob } from './Blob';
+import { toArrayBuffer } from './bytes';
+import { utf8Decode } from './utf8';
+
+const EMPTY = 0;
+const LOADING = 1;
+const DONE = 2;
+
+const CHARSET_PARAMETER_PATTERN = /;\s*charset\s*=\s*("([^"]*)"|([^;\s]*))/i;
+
+export class FileReader {
+  static readonly EMPTY = EMPTY;
+  static readonly LOADING = LOADING;
+  static readonly DONE = DONE;
+
+  readonly EMPTY = EMPTY;
+  readonly LOADING = LOADING;
+  readonly DONE = DONE;
+
+  readyState = EMPTY;
+  result: string | ArrayBuffer | null = null;
+  error: unknown = null;
+
+  onload: (() => void) | null = null;
+  onerror: (() => void) | null = null;
+  onloadend: (() => void) | null = null;
+
+  readAsArrayBuffer(blob: Blob) {
+    this.read(() => toArrayBuffer(readBytes(blob)));
+  }
+
+  readAsText(blob: Blob, encoding?: string) {
+    this.read(() => {
+      const bytes = readBytes(blob);
+      const resolvedEncoding = encoding ?? extractCharset(blob.type);
+      const networking = globalThis.__workletsNetworking;
+      if (networking !== undefined) {
+        return networking.decodeText(toArrayBuffer(bytes), resolvedEncoding);
+      }
+      return utf8Decode(bytes);
+    });
+  }
+
+  private read(produceResult: () => string | ArrayBuffer) {
+    if (this.readyState === LOADING) {
+      throw new Error(
+        "[Worklets] Failed to execute 'read' on 'FileReader': the object is already loading."
+      );
+    }
+    this.result = null;
+    this.error = null;
+    this.readyState = LOADING;
+    /**
+     * The File API fires read events from a task, not from a microtask, so
+     * `setTimeout` is used here rather than `queueMicrotask`. Reads are started
+     * from Promise continuations, which makes the distinction observable.
+     */
+    setTimeout(() => {
+      let failed = false;
+      try {
+        this.result = produceResult();
+      } catch (error) {
+        this.error = error;
+        failed = true;
+      }
+      this.readyState = DONE;
+      invoke(failed ? this.onerror : this.onload);
+      invoke(this.onloadend);
+    });
+  }
+}
+
+function invoke(handler: (() => void) | null) {
+  try {
+    handler?.();
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+function readBytes(blob: Blob): Uint8Array {
+  if (typeof blob?.__getBytes !== 'function') {
+    throw new Error(
+      '[Worklets] FileReader can only read a Blob created by the Worklets networking module.'
+    );
+  }
+  return blob.__getBytes();
+}
+
+function extractCharset(mimeType: string): string | undefined {
+  const match = CHARSET_PARAMETER_PATTERN.exec(mimeType);
+  if (match === null) {
+    return undefined;
+  }
+  const charset = match[2] ?? match[3] ?? '';
+  return charset !== '' ? charset : undefined;
+}

package/src/networking/FormData.ts

@@ -0,0 +1,135 @@
+'use strict';
+
+import { toArrayBuffer } from './bytes';
+import { utf8Encode } from './utf8';
+
+export class FormData {
+  private formEntries: Array<[string, string]> = [];
+
+  get [Symbol.toStringTag]() {
+    return 'FormData';
+  }
+
+  append(name: string, value: unknown) {
+    if (value !== null && typeof value === 'object') {
+      throw new TypeError(
+        "[Worklets] Failed to execute 'append' on 'FormData': only string values are supported."
+      );
+    }
+    this.formEntries.push([String(name), String(value)]);
+  }
+
+  set(name: string, value: unknown) {
+    this.delete(name);
+    this.append(name, value);
+  }
+
+  get(name: string): string | null {
+    const entry = this.formEntries.find(
+      ([entryName]) => entryName === String(name)
+    );
+    return entry !== undefined ? entry[1] : null;
+  }
+
+  getAll(name: string): string[] {
+    return this.formEntries
+      .filter(([entryName]) => entryName === String(name))
+      .map(([, value]) => value);
+  }
+
+  has(name: string): boolean {
+    return this.formEntries.some(([entryName]) => entryName === String(name));
+  }
+
+  delete(name: string) {
+    this.formEntries = this.formEntries.filter(
+      ([entryName]) => entryName !== String(name)
+    );
+  }
+
+  forEach(callback: (value: string, name: string, formData: FormData) => void) {
+    for (const [name, value] of this.formEntries) {
+      callback(value, name, this);
+    }
+  }
+
+  *entries(): IterableIterator<[string, string]> {
+    for (const [name, value] of this.formEntries) {
+      yield [name, value];
+    }
+  }
+
+  *keys(): IterableIterator<string> {
+    for (const [name] of this.formEntries) {
+      yield name;
+    }
+  }
+
+  *values(): IterableIterator<string> {
+    for (const [, value] of this.formEntries) {
+      yield value;
+    }
+  }
+
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+
+  /**
+   * Mirrors React Native's non-standard `FormData.getParts`. Its presence makes
+   * libraries like Axios treat this object as a React Native `FormData` and
+   * leave the multipart encoding to `XMLHttpRequest`.
+   */
+  getParts(): Array<{
+    string: string;
+    fieldName: string;
+    headers: Record<string, string>;
+  }> {
+    return this.formEntries.map(([name, value]) => ({
+      string: value,
+      fieldName: name,
+      headers: {
+        'content-disposition': `form-data; name="${escapeName(name)}"`,
+      },
+    }));
+  }
+
+  __encodeMultipart(): { body: ArrayBuffer; contentType: string } {
+    const parts = this.formEntries.map(
+      ([name, value]) =>
+        `content-disposition: form-data; name="${escapeName(name)}"\r\n\r\n${value}`
+    );
+    const boundary = pickBoundary(parts);
+    let encoded = '';
+    for (const part of parts) {
+      encoded += `--${boundary}\r\n${part}\r\n`;
+    }
+    encoded += `--${boundary}--\r\n`;
+    return {
+      body: toArrayBuffer(utf8Encode(encoded)),
+      contentType: `multipart/form-data; boundary=${boundary}`,
+    };
+  }
+}
+
+/**
+ * Picks a boundary that appears in none of the parts. Entry values are written
+ * verbatim, so a value that contained the boundary could otherwise inject
+ * arbitrary parts into the request.
+ */
+function pickBoundary(parts: string[]): string {
+  for (;;) {
+    const boundary = `----WorkletsFormDataBoundary${randomToken()}${randomToken()}`;
+    if (!parts.some((part) => part.includes(boundary))) {
+      return boundary;
+    }
+  }
+}
+
+function randomToken(): string {
+  return Math.random().toString(36).slice(2).padEnd(11, '0');
+}
+
+function escapeName(name: string): string {
+  return name.replace(/\r/g, '%0D').replace(/\n/g, '%0A').replace(/"/g, '%22');
+}