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

package/lib/module/networking/FileReader.js

@@ -0,0 +1,83 @@
+'use strict';
+
+import { toArrayBuffer } from "./bytes.js";
+import { utf8Decode } from "./utf8.js";
+const EMPTY = 0;
+const LOADING = 1;
+const DONE = 2;
+const CHARSET_PARAMETER_PATTERN = /;\s*charset\s*=\s*("([^"]*)"|([^;\s]*))/i;
+export class FileReader {
+  static EMPTY = EMPTY;
+  static LOADING = LOADING;
+  static DONE = DONE;
+  EMPTY = EMPTY;
+  LOADING = LOADING;
+  DONE = DONE;
+  readyState = EMPTY;
+  result = null;
+  error = null;
+  onload = null;
+  onerror = null;
+  onloadend = null;
+  readAsArrayBuffer(blob) {
+    this.read(() => toArrayBuffer(readBytes(blob)));
+  }
+  readAsText(blob, encoding) {
+    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);
+    });
+  }
+  read(produceResult) {
+    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) {
+  try {
+    handler?.();
+  } catch (error) {
+    console.error(error);
+  }
+}
+function readBytes(blob) {
+  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) {
+  const match = CHARSET_PARAMETER_PATTERN.exec(mimeType);
+  if (match === null) {
+    return undefined;
+  }
+  const charset = match[2] ?? match[3] ?? '';
+  return charset !== '' ? charset : undefined;
+}
+//# sourceMappingURL=FileReader.js.map

package/lib/module/networking/FileReader.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["toArrayBuffer","utf8Decode","EMPTY","LOADING","DONE","CHARSET_PARAMETER_PATTERN","FileReader","readyState","result","error","onload","onerror","onloadend","readAsArrayBuffer","blob","read","readBytes","readAsText","encoding","bytes","resolvedEncoding","extractCharset","type","networking","globalThis","__workletsNetworking","undefined","decodeText","produceResult","Error","setTimeout","failed","invoke","handler","console","__getBytes","mimeType","match","exec","charset"],"sourceRoot":"../../../src","sources":["networking/FileReader.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/networking/FormData.js

@@ -0,0 +1,105 @@
+'use strict';
+
+import { toArrayBuffer } from "./bytes.js";
+import { utf8Encode } from "./utf8.js";
+export class FormData {
+  formEntries = [];
+  get [Symbol.toStringTag]() {
+    return 'FormData';
+  }
+  append(name, value) {
+    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, value) {
+    this.delete(name);
+    this.append(name, value);
+  }
+  get(name) {
+    const entry = this.formEntries.find(([entryName]) => entryName === String(name));
+    return entry !== undefined ? entry[1] : null;
+  }
+  getAll(name) {
+    return this.formEntries.filter(([entryName]) => entryName === String(name)).map(([, value]) => value);
+  }
+  has(name) {
+    return this.formEntries.some(([entryName]) => entryName === String(name));
+  }
+  delete(name) {
+    this.formEntries = this.formEntries.filter(([entryName]) => entryName !== String(name));
+  }
+  forEach(callback) {
+    for (const [name, value] of this.formEntries) {
+      callback(value, name, this);
+    }
+  }
+  *entries() {
+    for (const [name, value] of this.formEntries) {
+      yield [name, value];
+    }
+  }
+  *keys() {
+    for (const [name] of this.formEntries) {
+      yield name;
+    }
+  }
+  *values() {
+    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() {
+    return this.formEntries.map(([name, value]) => ({
+      string: value,
+      fieldName: name,
+      headers: {
+        'content-disposition': `form-data; name="${escapeName(name)}"`
+      }
+    }));
+  }
+  __encodeMultipart() {
+    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) {
+  for (;;) {
+    const boundary = `----WorkletsFormDataBoundary${randomToken()}${randomToken()}`;
+    if (!parts.some(part => part.includes(boundary))) {
+      return boundary;
+    }
+  }
+}
+function randomToken() {
+  return Math.random().toString(36).slice(2).padEnd(11, '0');
+}
+function escapeName(name) {
+  return name.replace(/\r/g, '%0D').replace(/\n/g, '%0A').replace(/"/g, '%22');
+}
+//# sourceMappingURL=FormData.js.map

package/lib/module/networking/FormData.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["toArrayBuffer","utf8Encode","FormData","formEntries","Symbol","toStringTag","append","name","value","TypeError","push","String","set","delete","get","entry","find","entryName","undefined","getAll","filter","map","has","some","forEach","callback","entries","keys","values","iterator","getParts","string","fieldName","headers","escapeName","__encodeMultipart","parts","boundary","pickBoundary","encoded","part","body","contentType","randomToken","includes","Math","random","toString","slice","padEnd","replace"],"sourceRoot":"../../../src","sources":["networking/FormData.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/networking/XMLHttpRequest.js

@@ -0,0 +1,450 @@
+'use strict';
+
+import { Blob } from "./Blob.js";
+import { toArrayBuffer } from "./bytes.js";
+import { DOMException } from "./DOMException.js";
+import { EventTargetLite } from "./events.js";
+import { FormData } from "./FormData.js";
+import { combineHeader, extractCharset, getHeader, hasHeader, isForbiddenMethod, isForbiddenRequestHeader, isHeaderName, isHeaderValue, isSupportedRequestUrl, isToken, normalizeHeaderValue, normalizeMethod, sortAndCombineHeaders } from "./http.js";
+import { stripUtf8Bom, utf8Decode, utf8Encode } from "./utf8.js";
+const UNSENT = 0;
+const OPENED = 1;
+const HEADERS_RECEIVED = 2;
+const LOADING = 3;
+const DONE = 4;
+const RESPONSE_TYPES = ['', 'text', 'arraybuffer', 'blob', 'json'];
+class XMLHttpRequestUpload extends EventTargetLite {}
+export class XMLHttpRequest extends EventTargetLite {
+  static UNSENT = UNSENT;
+  static OPENED = OPENED;
+  static HEADERS_RECEIVED = HEADERS_RECEIVED;
+  static LOADING = LOADING;
+  static DONE = DONE;
+  UNSENT = UNSENT;
+  OPENED = OPENED;
+  HEADERS_RECEIVED = HEADERS_RECEIVED;
+  LOADING = LOADING;
+  DONE = DONE;
+  readyState = UNSENT;
+  status = 0;
+  statusText = '';
+  responseURL = '';
+  timeout = 0;
+  /**
+   * The specification defaults this to `false`. React Native's own
+   * `XMLHttpRequest` defaults it to `true`, and Worklet Runtimes share the
+   * app's cookie storage, so the parity is deliberate.
+   */
+  withCredentials = true;
+  upload = new XMLHttpRequestUpload();
+  onreadystatechange = null;
+  onloadstart = null;
+  onprogress = null;
+  onload = null;
+  onloadend = null;
+  onerror = null;
+  ontimeout = null;
+  onabort = null;
+  requestId = null;
+  requestToken = 0;
+  method = 'GET';
+  url = '';
+  sent = false;
+  hasRequestBody = false;
+  requestBodyLength = 0;
+  uploadSettled = false;
+  downloadedBytes = 0;
+  mimeTypeOverride = null;
+  requestHeaders = [];
+  responseHeaders = [];
+  responseTypeValue = '';
+  responseBytes = null;
+  responseBlobValue = null;
+  responseTextValue = null;
+  responseJsonValue = undefined;
+  get responseType() {
+    return this.responseTypeValue;
+  }
+  set responseType(value) {
+    if (this.readyState >= LOADING) {
+      throw new DOMException("[Worklets] Failed to set 'responseType' on 'XMLHttpRequest': the response type cannot be changed once loading has started.", 'InvalidStateError');
+    }
+    if (!RESPONSE_TYPES.includes(value)) {
+      return;
+    }
+    this.responseTypeValue = value;
+  }
+  get response() {
+    switch (this.responseTypeValue) {
+      case '':
+      case 'text':
+        return this.readyState >= LOADING ? this.getResponseText() : '';
+      case 'arraybuffer':
+        return this.readyState === DONE ? this.responseBytes : null;
+      case 'blob':
+        if (this.readyState !== DONE || this.responseBytes === null) {
+          return null;
+        }
+        if (this.responseBlobValue === null) {
+          this.responseBlobValue = new Blob([this.responseBytes], {
+            type: this.mimeTypeOverride ?? this.getResponseHeader('content-type') ?? ''
+          });
+        }
+        return this.responseBlobValue;
+      case 'json':
+        if (this.readyState !== DONE) {
+          return null;
+        }
+        if (this.responseJsonValue === undefined) {
+          try {
+            this.responseJsonValue = JSON.parse(this.responseBytes === null ? '' : utf8Decode(stripUtf8Bom(new Uint8Array(this.responseBytes))));
+          } catch {
+            this.responseJsonValue = null;
+          }
+        }
+        return this.responseJsonValue;
+      default:
+        return null;
+    }
+  }
+  get responseText() {
+    if (this.responseTypeValue !== '' && this.responseTypeValue !== 'text') {
+      throw new DOMException("[Worklets] Failed to read 'responseText' on 'XMLHttpRequest': the value is only accessible if the object's 'responseType' is '' or 'text'.", 'InvalidStateError');
+    }
+    return this.readyState >= LOADING ? this.getResponseText() : '';
+  }
+  open(method, url, async = true) {
+    const methodValue = String(method);
+    const urlValue = String(url);
+    if (!isToken(methodValue)) {
+      throw new DOMException(`[Worklets] Failed to execute 'open' on 'XMLHttpRequest': '${methodValue}' is not a valid HTTP method.`, 'SyntaxError');
+    }
+    if (isForbiddenMethod(methodValue)) {
+      throw new DOMException(`[Worklets] Failed to execute 'open' on 'XMLHttpRequest': '${methodValue}' HTTP method is unsupported.`, 'SecurityError');
+    }
+    if (urlValue === '') {
+      throw new DOMException("[Worklets] Failed to execute 'open' on 'XMLHttpRequest': the URL cannot be empty.", 'SyntaxError');
+    }
+    if (!async) {
+      throw new DOMException('[Worklets] Synchronous XMLHttpRequest is not supported.', 'InvalidAccessError');
+    }
+    this.terminate();
+    this.method = normalizeMethod(methodValue);
+    this.url = urlValue;
+    this.sent = false;
+    this.hasRequestBody = false;
+    this.requestBodyLength = 0;
+    this.uploadSettled = false;
+    this.mimeTypeOverride = null;
+    this.requestHeaders = [];
+    this.resetResponse();
+    if (this.readyState !== OPENED) {
+      this.setReadyState(OPENED);
+    } else {
+      this.readyState = OPENED;
+    }
+  }
+  setRequestHeader(name, value) {
+    if (this.readyState !== OPENED || this.sent) {
+      throw new DOMException("[Worklets] Failed to execute 'setRequestHeader' on 'XMLHttpRequest': the object's state must be OPENED.", 'InvalidStateError');
+    }
+    const nameValue = String(name);
+    const headerValue = normalizeHeaderValue(String(value));
+    if (!isHeaderName(nameValue) || !isHeaderValue(headerValue)) {
+      throw new DOMException(`[Worklets] Failed to execute 'setRequestHeader' on 'XMLHttpRequest': '${nameValue}: ${headerValue}' is not a valid header.`, 'SyntaxError');
+    }
+    if (isForbiddenRequestHeader(nameValue, headerValue)) {
+      return;
+    }
+    combineHeader(this.requestHeaders, nameValue, headerValue);
+  }
+  getAllResponseHeaders() {
+    return sortAndCombineHeaders(this.responseHeaders);
+  }
+  getResponseHeader(name) {
+    return getHeader(this.responseHeaders, String(name));
+  }
+  overrideMimeType(mimeType) {
+    if (this.readyState >= LOADING) {
+      throw new DOMException("[Worklets] Failed to execute 'overrideMimeType' on 'XMLHttpRequest': the MIME type cannot be overridden once loading has started.", 'InvalidStateError');
+    }
+    this.mimeTypeOverride = String(mimeType);
+    this.responseTextValue = null;
+  }
+  send(body) {
+    const networking = globalThis.__workletsNetworking;
+    if (networking === undefined) {
+      throw new DOMException('[Worklets] XMLHttpRequest is not available on this runtime.', 'InvalidStateError');
+    }
+    if (this.readyState !== OPENED || this.sent) {
+      throw new DOMException("[Worklets] Failed to execute 'send' on 'XMLHttpRequest': the object's state must be OPENED.", 'InvalidStateError');
+    }
+    this.sent = true;
+    if (!isSupportedRequestUrl(this.url)) {
+      this.__dispatch('loadstart');
+      setTimeout(() => this.handleRequestError('network', `Only http and https URLs are supported, got '${this.url}'.`));
+      return;
+    }
+    const {
+      data,
+      contentType
+    } = this.method === 'GET' || this.method === 'HEAD' ? {
+      data: undefined,
+      contentType: undefined
+    } : normalizeBody(body);
+    const headers = [...this.requestHeaders];
+    if (contentType !== undefined && !hasHeader(headers, 'content-type')) {
+      headers.push(['Content-Type', contentType]);
+    }
+    this.hasRequestBody = data !== undefined;
+    this.requestBodyLength = typeof data === 'string' ? utf8Encode(data).length : data?.byteLength ?? 0;
+    const token = ++this.requestToken;
+    this.requestId = networking.sendRequest({
+      method: this.method,
+      url: this.url,
+      headers,
+      body: data,
+      timeoutMs: this.timeout,
+      withCredentials: this.withCredentials
+    }, (type, payload) => {
+      if (token === this.requestToken && this.requestId !== null) {
+        this.handleNetworkingEvent(type, payload);
+      }
+    });
+    this.__dispatch('loadstart');
+    if (this.hasRequestBody) {
+      this.upload.__dispatch('loadstart', {
+        loaded: 0,
+        total: this.requestBodyLength,
+        lengthComputable: this.requestBodyLength > 0
+      });
+    }
+  }
+  abort() {
+    const wasInFlight = this.terminate();
+    if (this.readyState === OPENED && !this.sent) {
+      return;
+    }
+    if (!wasInFlight || this.readyState === UNSENT) {
+      this.readyState = UNSENT;
+      return;
+    }
+    if (this.readyState === DONE) {
+      this.resetResponse();
+      this.readyState = UNSENT;
+      return;
+    }
+    this.resetResponse();
+    this.setReadyState(DONE);
+    this.settleUploadWithError('abort');
+    this.__dispatch('abort');
+    this.__dispatch('loadend');
+    if (this.readyState === DONE) {
+      this.readyState = UNSENT;
+    }
+  }
+  handleNetworkingEvent(type, payload) {
+    switch (type) {
+      case 'response':
+        {
+          const {
+            status,
+            statusText,
+            headers,
+            url
+          } = payload;
+          this.status = status;
+          this.statusText = statusText;
+          this.responseHeaders = headers;
+          this.responseURL = url;
+          this.settleUploadWithSuccess();
+          this.setReadyState(HEADERS_RECEIVED);
+          break;
+        }
+      case 'downloadProgress':
+        {
+          const {
+            loaded,
+            total
+          } = payload;
+          this.downloadedBytes = loaded;
+          if (this.readyState === HEADERS_RECEIVED) {
+            this.setReadyState(LOADING);
+          } else {
+            this.__dispatch('readystatechange');
+          }
+          this.__dispatch('progress', {
+            loaded,
+            total: total > 0 ? total : 0,
+            lengthComputable: total > 0
+          });
+          break;
+        }
+      case 'uploadProgress':
+        {
+          const {
+            loaded,
+            total
+          } = payload;
+          this.upload.__dispatch('progress', {
+            loaded,
+            total: total > 0 ? total : 0,
+            lengthComputable: total > 0
+          });
+          break;
+        }
+      case 'done':
+        {
+          this.requestId = null;
+          const {
+            body,
+            error,
+            message
+          } = payload;
+          if (error !== undefined) {
+            this.handleRequestError(error, message);
+          } else if (this.status === 0) {
+            this.handleRequestError('network', 'The request completed without a response.');
+          } else {
+            this.handleResponseEndOfBody(body);
+          }
+          break;
+        }
+    }
+  }
+  handleRequestError(error, message) {
+    const terminalEvent = error === 'timeout' ? 'timeout' : error === 'aborted' ? 'abort' : 'error';
+    this.resetResponse();
+    this.setReadyState(DONE);
+    this.settleUploadWithError(terminalEvent);
+    this.__dispatch(terminalEvent, {
+      message
+    });
+    this.__dispatch('loadend');
+  }
+  handleResponseEndOfBody(body) {
+    this.responseBytes = body ?? new ArrayBuffer(0);
+    this.responseTextValue = null;
+    this.responseBlobValue = null;
+    this.responseJsonValue = undefined;
+    const transmitted = Math.max(this.responseBytes.byteLength, this.downloadedBytes);
+    const rawContentLength = this.getResponseHeader('content-length');
+    const contentLength = rawContentLength === null ? Number.NaN : Number(rawContentLength);
+    const total = Number.isInteger(contentLength) && contentLength > 0 ? contentLength : 0;
+    const progress = {
+      loaded: transmitted,
+      total,
+      lengthComputable: total > 0
+    };
+    this.settleUploadWithSuccess();
+    this.__dispatch('progress', progress);
+    this.setReadyState(DONE);
+    this.__dispatch('load', progress);
+    this.__dispatch('loadend', progress);
+  }
+  settleUploadWithSuccess() {
+    if (!this.hasRequestBody || this.uploadSettled) {
+      return;
+    }
+    this.uploadSettled = true;
+    const progress = {
+      loaded: this.requestBodyLength,
+      total: this.requestBodyLength,
+      lengthComputable: this.requestBodyLength > 0
+    };
+    this.upload.__dispatch('progress', progress);
+    this.upload.__dispatch('load', progress);
+    this.upload.__dispatch('loadend', progress);
+  }
+  settleUploadWithError(type) {
+    if (!this.hasRequestBody || this.uploadSettled) {
+      return;
+    }
+    this.uploadSettled = true;
+    this.upload.__dispatch(type);
+    this.upload.__dispatch('loadend');
+  }
+  getResponseText() {
+    if (this.responseTextValue === null) {
+      this.responseTextValue = decodeResponseText(this.responseBytes, extractCharset(this.mimeTypeOverride) ?? extractCharset(this.getResponseHeader('content-type')));
+    }
+    return this.responseTextValue;
+  }
+  resetResponse() {
+    this.status = 0;
+    this.statusText = '';
+    this.responseURL = '';
+    this.downloadedBytes = 0;
+    this.responseHeaders = [];
+    this.responseBytes = null;
+    this.responseTextValue = null;
+    this.responseBlobValue = null;
+    this.responseJsonValue = undefined;
+  }
+  terminate() {
+    if (this.requestId === null) {
+      return this.sent;
+    }
+    globalThis.__workletsNetworking?.abortRequest(this.requestId);
+    this.requestId = null;
+    return true;
+  }
+  setReadyState(readyState) {
+    this.readyState = readyState;
+    this.__dispatch('readystatechange');
+  }
+}
+function decodeResponseText(bytes, charset) {
+  if (bytes === null || bytes.byteLength === 0) {
+    return '';
+  }
+  const networking = globalThis.__workletsNetworking;
+  if (networking !== undefined) {
+    return networking.decodeText(bytes, charset);
+  }
+  return utf8Decode(new Uint8Array(bytes));
+}
+function isBlobLike(body) {
+  return typeof body?.__getBytes === 'function';
+}
+function normalizeBody(body) {
+  if (body === null || body === undefined) {
+    return {};
+  }
+  if (typeof body === 'string') {
+    return {
+      data: body,
+      contentType: 'text/plain;charset=UTF-8'
+    };
+  }
+  if (body instanceof ArrayBuffer) {
+    return {
+      data: body
+    };
+  }
+  if (isBlobLike(body)) {
+    return {
+      data: toArrayBuffer(body.__getBytes()),
+      contentType: body.type !== '' ? body.type : undefined
+    };
+  }
+  if (body instanceof FormData) {
+    const {
+      body: data,
+      contentType
+    } = body.__encodeMultipart();
+    return {
+      data,
+      contentType
+    };
+  }
+  if (ArrayBuffer.isView(body)) {
+    return {
+      data: toArrayBuffer(new Uint8Array(body.buffer, body.byteOffset, body.byteLength))
+    };
+  }
+  return {
+    data: String(body)
+  };
+}
+//# sourceMappingURL=XMLHttpRequest.js.map