@metapages/metapage 1.9.2 → 1.9.3

package/dist/metapage/data.d.ts

@@ -18,8 +18,8 @@ export type DataRefSerializedFile = DataRefSerializedBlob & {
     name: string;
     lastModified?: number;
 };
+export declare const possiblySerializeValueToDataref: <T>(value: T) => Promise<string | T>;
+export declare const possiblyDeserializeDatarefToValue: (value: any) => Promise<any>;
+export declare const possiblyDeserializeDatarefToFile: (value: any) => Promise<File | undefined>;
 export declare const valueToFile: (value: any, fileName: string, options?: FilePropertyBag) => Promise<File>;
-export declare const possiblySerializeValueToDataref: <T>(value: T) => Promise<DataRefSerialized | T>;
-export declare const possiblyDeserializeDatarefToValue: (value: any) => any;
-export declare const possiblyDeserializeDatarefToFile: (value: any) => File | undefined;
 //# sourceMappingURL=data.d.ts.map

package/dist/metapage/data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../src/metapage/data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAS3C,eAAO,MAAM,eAAe,WAClB,iBAAiB,KACxB,QAAQ,iBAAiB,CAS3B,CAAC;AAOF,eAAO,MAAM,iBAAiB,WACpB,iBAAiB,KACxB,QAAQ,iBAAiB,CAW3B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAE9B,EAAE,EAAE,IAAI,CAAC;IAET,EAAE,EAAE,MAAM,CAAC;IAEX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,iBAAiB,GAAG;IAE5D,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,GAAG;IACtD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,qBAAqB,GAAG;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,WAAW,UACf,GAAG,YACA,MAAM,YACN,eAAe,KACxB,QAAQ,IAAI,CAgDd,CAAC;AAEF,eAAO,MAAM,+BAA+B,iDA2D3C,CAAC;AAEF,eAAO,MAAM,iCAAiC,UAAW,GAAG,KAAG,GAiD9D,CAAC;AAEF,eAAO,MAAM,gCAAgC,UACpC,GAAG,KACT,IAAI,GAAG,SAoDT,CAAC"}
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../src/metapage/data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAkC3C,eAAO,MAAM,eAAe,WAClB,iBAAiB,KACxB,QAAQ,iBAAiB,CAa3B,CAAC;AAOF,eAAO,MAAM,iBAAiB,WACpB,iBAAiB,KACxB,QAAQ,iBAAiB,CAa3B,CAAC;AAGF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,IAAI,CAAC;IACT,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,iBAAiB,GAAG;IAC5D,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,GAAG;IACtD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,qBAAqB,GAAG;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAoBF,eAAO,MAAM,+BAA+B,sCAgC3C,CAAC;AASF,eAAO,MAAM,iCAAiC,UACrC,GAAG,KACT,QAAQ,GAAG,CAsBb,CAAC;AAMF,eAAO,MAAM,gCAAgC,UACpC,GAAG,KACT,QAAQ,IAAI,GAAG,SAAS,CAmB1B,CAAC;AAEF,eAAO,MAAM,WAAW,UACf,GAAG,YACA,MAAM,YACN,eAAe,KACxB,QAAQ,IAAI,CAoCd,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@metapages/metapage",
   "public": true,
-  "version": "1.9.2",
+  "version": "1.9.3",
   "description": "Connect web pages together",
   "repository": "https://github.com/metapages/metapage",
   "homepage": "https://metapage.io/",
@@ -23,6 +23,7 @@
   ],
   "source": "src/index.ts",
   "dependencies": {
+    "@metapages/dataref": "^2.0.1",
     "@metapages/hash-query": "^0.9.8",
     "base64-arraybuffer": "^1.0.2",
     "compare-versions": "^6.1.1",

package/src/metapage/data.ts

@@ -1,57 +1,85 @@
 import { MetaframeInputMap } from "./v0_4";
-import { encode, decode } from "base64-arraybuffer";
-import { create } from "mutative";
+import { decode } from "base64-arraybuffer";
+import {
+  typedArrayToDataUrl,
+  bufferToDataUrl,
+  dataUrlToBuffer,
+  dataUrlToTypedArray,
+  isDataUrl,
+  getParameters,
+  getMimeType,
+  type TypedArrayType,
+} from "@metapages/dataref";
+
+/** Cheap sync check: does this value need serialization? */
+const needsSerialization = (value: any): boolean =>
+  value instanceof ArrayBuffer ||
+  value instanceof Blob || // File extends Blob, so this catches both
+  ArrayBuffer.isView(value);
+
+/** Cheap sync check: does this value need deserialization? */
+const needsDeserialization = (value: any): boolean => {
+  if (typeof value === "string") return value.startsWith("data:");
+  if (value && typeof value === "object") {
+    if (value._s === true && value._c) return true;
+    if (value.ref === "base64" && value.c) return true;
+  }
+  return false;
+};
 
 /**
- * Modifies in place!!!
- * @param inputs
- * @returns
+ * Serialize all values in inputs (one level deep).
+ * Binary types (TypedArray, ArrayBuffer, Blob, File) become data URL strings.
+ * Returns the original object if nothing needs serialization.
  */
 export const serializeInputs = async (
   inputs: MetaframeInputMap,
 ): Promise<MetaframeInputMap> => {
-  // only serialize one level deep
-  return create<MetaframeInputMap>(inputs, async (draft: MetaframeInputMap) => {
-    for (const key of Object.keys(inputs)) {
-      const maybeNewObject = await possiblySerializeValueToDataref(inputs[key]);
-      draft[key] = maybeNewObject;
-      return draft;
-    }
-  });
+  const keys = Object.keys(inputs);
+  const keysToSerialize: string[] = [];
+  for (const key of keys) {
+    if (needsSerialization(inputs[key])) keysToSerialize.push(key);
+  }
+  if (keysToSerialize.length === 0) return inputs;
+
+  const result: MetaframeInputMap = { ...inputs };
+  for (const key of keysToSerialize) {
+    result[key] = await possiblySerializeValueToDataref(inputs[key]);
+  }
+  return result;
 };
 
 /**
- * Modifies in place!!!
- * @param inputs
- * @returns
+ * Deserialize all values in inputs (one level deep).
+ * Handles v2 data URLs, legacy metapage _s/_c format, and dataref v1 ref/c format.
+ * Returns the original object if nothing needs deserialization.
  */
 export const deserializeInputs = async (
   inputs: MetaframeInputMap,
 ): Promise<MetaframeInputMap> => {
-  // only deserialize one level deep
-  return create<MetaframeInputMap>(inputs, async (draft: MetaframeInputMap) => {
-    for (const key of Object.keys(inputs)) {
-      const maybeNewObject = await possiblyDeserializeDatarefToValue(
-        inputs[key],
-      );
-      draft[key] = maybeNewObject;
-      return draft;
-    }
-  });
+  const keys = Object.keys(inputs);
+  const keysToDeserialize: string[] = [];
+  for (const key of keys) {
+    if (needsDeserialization(inputs[key])) keysToDeserialize.push(key);
+  }
+  if (keysToDeserialize.length === 0) return inputs;
+
+  const result: MetaframeInputMap = { ...inputs };
+  for (const key of keysToDeserialize) {
+    result[key] = await possiblyDeserializeDatarefToValue(inputs[key]);
+  }
+  return result;
 };
 
+// Legacy types kept for backwards-compatible deserialization
 export type DataRefSerialized = {
-  // This means it's a serialized DataRef
   _s: true;
-  // constructor
   _c: string;
-  // value is base64 encoded
   value: string;
   size: number;
 };
 
 export type DataRefSerializedTypedArray = DataRefSerialized & {
-  // Typed arrays are from ArrayBufferView
   byteLength: number;
   byteOffset: number;
 };
@@ -65,12 +93,124 @@ export type DataRefSerializedFile = DataRefSerializedBlob & {
   lastModified?: number;
 };
 
+const TYPED_ARRAY_NAMES: Set<string> = new Set([
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+]);
+
+/**
+ * Serialize a value to a data URL string if it's a binary type.
+ * Non-binary values pass through unchanged.
+ */
+export const possiblySerializeValueToDataref = async <T>(
+  value: T,
+): Promise<T | string> => {
+  if (
+    value instanceof Int8Array ||
+    value instanceof Uint8Array ||
+    value instanceof Uint8ClampedArray ||
+    value instanceof Int16Array ||
+    value instanceof Uint16Array ||
+    value instanceof Int32Array ||
+    value instanceof Uint32Array ||
+    value instanceof Float32Array ||
+    value instanceof Float64Array
+  ) {
+    return typedArrayToDataUrl(value, value.constructor.name as TypedArrayType);
+  } else if (value instanceof File) {
+    const arrayBuffer = await value.arrayBuffer();
+    const bytes = new Uint8Array(arrayBuffer);
+    const base64 = btoa(String.fromCharCode(...bytes));
+    const mimeType = value.type || "application/octet-stream";
+    const name = encodeURIComponent(value.name);
+    return `data:${mimeType};file=true;name=${name};lastModified=${value.lastModified};base64,${base64}`;
+  } else if (value instanceof Blob) {
+    const arrayBuffer = await value.arrayBuffer();
+    const bytes = new Uint8Array(arrayBuffer);
+    const base64 = btoa(String.fromCharCode(...bytes));
+    const mimeType = value.type || "application/octet-stream";
+    return `data:${mimeType};blob=true;base64,${base64}`;
+  } else if (value instanceof ArrayBuffer) {
+    return bufferToDataUrl(value);
+  }
+  return value;
+};
+
+/**
+ * Deserialize a value from any supported format:
+ * 1. v2 data URL strings (new format)
+ * 2. Legacy metapage format ({ _s: true, _c: "..." })
+ * 3. dataref v1 format ({ ref: "base64", c: "..." })
+ * 4. Anything else passes through unchanged
+ */
+export const possiblyDeserializeDatarefToValue = async (
+  value: any,
+): Promise<any> => {
+  // 1. v2 data URL string
+  if (isDataUrl(value)) {
+    return deserializeDataUrl(value);
+  }
+
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+
+  // 2. Legacy metapage format: { _s: true, _c: "ConstructorName", value: "base64..." }
+  if (value._s === true && value._c) {
+    return deserializeLegacyMetapage(value);
+  }
+
+  // 3. dataref v1 format: { ref: "base64", c: "ConstructorName", value: "base64..." }
+  if (value.ref === "base64" && value.c) {
+    return deserializeDatarefV1(value);
+  }
+
+  // 4. Pass through
+  return value;
+};
+
+/**
+ * Attempt to deserialize a value to a File. Returns undefined if the value
+ * is not a recognized serialized format.
+ */
+export const possiblyDeserializeDatarefToFile = async (
+  value: any,
+): Promise<File | undefined> => {
+  const deserialized = await possiblyDeserializeDatarefToValue(value);
+  if (deserialized instanceof File) {
+    return deserialized;
+  }
+  if (deserialized instanceof Blob) {
+    return new File([deserialized], "file", { type: deserialized.type });
+  }
+  if (deserialized instanceof ArrayBuffer) {
+    return new File([deserialized], "file", {
+      type: "application/octet-stream",
+    });
+  }
+  if (ArrayBuffer.isView(deserialized)) {
+    return new File([deserialized], "file", {
+      type: "application/octet-stream",
+    });
+  }
+  return undefined;
+};
+
 export const valueToFile = async (
   value: any,
   fileName: string,
   options?: FilePropertyBag,
 ): Promise<File> => {
-  value = possiblyDeserializeDatarefToValue(value);
+  value = await possiblyDeserializeDatarefToValue(value);
   options = options || {};
   if (!options.type) {
     options.type = "application/octet-stream";
@@ -82,26 +222,15 @@ export const valueToFile = async (
   if (value instanceof File || value instanceof Blob) {
     const buffer = await value.arrayBuffer();
     if (value instanceof File) {
-      options.type = (value as File).type;
+      options.type = value.type;
     }
     return new File([buffer], fileName, options);
   }
-  if (
-    value instanceof Int8Array ||
-    value instanceof Uint8Array ||
-    value instanceof Uint8ClampedArray ||
-    value instanceof Int16Array ||
-    value instanceof Uint16Array ||
-    value instanceof Int32Array ||
-    value instanceof Uint32Array ||
-    value instanceof Float32Array ||
-    value instanceof Float64Array
-  ) {
-    const typedValue = value as ArrayBufferView;
-    return new File([typedValue.buffer], fileName, options);
+  if (ArrayBuffer.isView(value)) {
+    return new File([value.buffer], fileName, options);
   }
   if (typeof value === "string") {
-    var blob = new Blob([value], { type: "text/plain" });
+    const blob = new Blob([value], { type: "text/plain" });
     options.type = "text/plain";
     return new File([blob], fileName, options);
   }
@@ -113,176 +242,94 @@ export const valueToFile = async (
     return new File([blob], fileName, options);
   }
 
-  // assume it's a string
-  var blob = new Blob([value as string], { type: "text/plain" });
+  const blob = new Blob([value as string], { type: "text/plain" });
   options.type = "text/plain";
   return new File([blob], fileName, options);
 };
 
-export const possiblySerializeValueToDataref = async <T>(
-  value: T,
-): Promise<T | DataRefSerialized> => {
-  if (
-    value instanceof Int8Array ||
-    value instanceof Uint8Array ||
-    value instanceof Uint8ClampedArray ||
-    value instanceof Int16Array ||
-    value instanceof Uint16Array ||
-    value instanceof Int32Array ||
-    value instanceof Uint32Array ||
-    value instanceof Float32Array ||
-    value instanceof Float64Array
-  ) {
-    const typedValue = value as ArrayBufferView;
-    const replacement: DataRefSerializedTypedArray = {
-      _s: true,
-      _c: value.constructor.name,
-      value: encode(typedValue.buffer),
-      byteLength: typedValue.byteLength,
-      byteOffset: typedValue.byteOffset,
-      size: typedValue.byteLength,
-    };
-    return Promise.resolve(replacement);
-  } else if (value instanceof File) {
-    const typedValue = value as File;
-    const arrayBuffer = await typedValue.arrayBuffer();
-    const replacement: DataRefSerializedFile = {
-      _s: true,
-      _c: File.name,
-      value: encode(arrayBuffer),
-      name: typedValue.name,
-      fileType: typedValue.type,
-      lastModified: typedValue.lastModified,
-      size: arrayBuffer.byteLength,
-    };
-    return replacement;
-  } else if (value instanceof Blob) {
-    const typedValue = value as Blob;
-    const arrayBuffer = await typedValue.arrayBuffer();
-    const replacement: DataRefSerializedBlob = {
-      _s: true,
-      _c: Blob.name,
-      value: encode(arrayBuffer),
-      fileType: typedValue.type,
-      size: arrayBuffer.byteLength,
-    };
-    return replacement;
-  } else if (value instanceof ArrayBuffer) {
-    const typedValue = value as ArrayBuffer;
-    const replacement: DataRefSerialized = {
-      _s: true,
-      _c: ArrayBuffer.name,
-      value: encode(typedValue),
-      size: typedValue.byteLength,
-    };
-    return Promise.resolve(replacement);
+// --- Internal helpers ---
+
+async function deserializeDataUrl(dataUrl: string): Promise<any> {
+  const params = getParameters(dataUrl);
+
+  // TypedArray: has "type" parameter (e.g. type=Float32Array)
+  if (params.type && TYPED_ARRAY_NAMES.has(params.type)) {
+    return dataUrlToTypedArray(dataUrl);
   }
-  return Promise.resolve(value);
-};
 
-export const possiblyDeserializeDatarefToValue = (value: any): any => {
-  if (
-    !(
-      value &&
-      typeof value === "object" &&
-      (value as DataRefSerialized)._s === true
-    )
-  ) {
-    return value;
+  // File: has "file=true" parameter
+  if (params.file === "true") {
+    const name = params.name ? decodeURIComponent(params.name) : "file";
+    const lastModified = params.lastModified
+      ? parseInt(params.lastModified, 10)
+      : undefined;
+    const mimeType = getMimeType(dataUrl);
+    const buffer = await dataUrlToBuffer(dataUrl);
+    return new File([buffer], name, { type: mimeType, lastModified });
   }
-  const serializedRef = value as DataRefSerialized;
-  const _c: string = serializedRef._c;
-  if (_c === Blob.name) {
-    const serializedRefBlob = value as DataRefSerializedBlob;
-    const blob = new Blob([decode(serializedRef.value)], {
-      type: serializedRefBlob.fileType,
-    });
-    return blob;
-  } else if (_c === File.name) {
-    const serializedRefFile = value as DataRefSerializedFile;
-    const file = new File(
-      [decode(serializedRef.value)],
-      serializedRefFile.name,
-      {
-        type: serializedRefFile.fileType,
-        lastModified: serializedRefFile.lastModified,
-      },
-    );
-    return file;
-  } else if (_c === ArrayBuffer.name) {
-    const arrayBuffer: ArrayBuffer = decode(serializedRef.value);
-    return arrayBuffer;
+
+  // Blob: has "blob=true" parameter
+  if (params.blob === "true") {
+    const mimeType = getMimeType(dataUrl);
+    const buffer = await dataUrlToBuffer(dataUrl);
+    return new Blob([buffer], { type: mimeType });
   }
-  // Assume typed array
-  const serializedRefTypedArray = value as DataRefSerializedTypedArray;
 
-  const arrayBuffer: ArrayBuffer = decode(serializedRefTypedArray.value);
-  const constructorName: string = serializedRefTypedArray._c;
+  // Plain ArrayBuffer
+  return dataUrlToBuffer(dataUrl);
+}
 
-  try {
-    // @ts-ignore
-    const typedArray: ArrayBufferView = new globalThis[constructorName](
-      arrayBuffer,
-      // serializedRefTypedArray.byteOffset,
-      // serializedRefTypedArray.byteLength
-    );
-    return typedArray;
-  } catch (e) {}
+function deserializeLegacyMetapage(value: DataRefSerialized): any {
+  const _c = value._c;
+  if (_c === "Blob") {
+    const v = value as DataRefSerializedBlob;
+    return new Blob([decode(value.value)], { type: v.fileType });
+  } else if (_c === "File") {
+    const v = value as DataRefSerializedFile;
+    return new File([decode(value.value)], v.name, {
+      type: v.fileType,
+      lastModified: v.lastModified,
+    });
+  } else if (_c === "ArrayBuffer") {
+    return decode(value.value);
+  }
+  // Typed array
+  const arrayBuffer = decode(value.value);
+  if (TYPED_ARRAY_NAMES.has(_c)) {
+    try {
+      // @ts-ignore
+      return new globalThis[_c](arrayBuffer);
+    } catch (_) {}
+  }
   return value;
-};
+}
 
-export const possiblyDeserializeDatarefToFile = (
-  value: any,
-): File | undefined => {
-  if (
-    !(
-      value &&
-      typeof value === "object" &&
-      (value as DataRefSerialized)._s === true
-    )
-  ) {
-    return undefined;
-  }
-  const serializedRef = value as DataRefSerialized;
-  const _c: string = serializedRef._c;
-  if (_c === Blob.name) {
-    const serializedRefBlob = value as DataRefSerializedBlob;
-    const blob = new Blob([decode(serializedRef.value)], {
-      type: serializedRefBlob.fileType,
-    });
-    return new File([blob], "file", {
-      type: blob.type,
+function deserializeDatarefV1(value: {
+  ref: string;
+  c: string;
+  value: string;
+  [key: string]: any;
+}): any {
+  const _c = value.c;
+  if (_c === "Blob") {
+    return new Blob([decode(value.value)], {
+      type: value.fileType || undefined,
     });
-  } else if (_c === File.name) {
-    const serializedRefFile = value as DataRefSerializedFile;
-    const file = new File(
-      [decode(serializedRef.value)],
-      serializedRefFile.name,
-      {
-        type: serializedRefFile.fileType,
-        lastModified: serializedRefFile.lastModified,
-      },
-    );
-    return file;
-  } else if (_c === ArrayBuffer.name) {
-    const arrayBuffer: ArrayBuffer = decode(serializedRef.value);
-    return new File([arrayBuffer], "file", {
-      type: "application/octet-stream",
+  } else if (_c === "File") {
+    return new File([decode(value.value)], value.name || "file", {
+      type: value.fileType || undefined,
+      lastModified: value.lastModified || undefined,
     });
+  } else if (_c === "ArrayBuffer") {
+    return decode(value.value);
   }
-  // Assume typed array
-  const serializedRefTypedArray = value as DataRefSerializedTypedArray;
-  const arrayBuffer: ArrayBuffer = decode(serializedRefTypedArray.value);
-  const constructorName: string = serializedRefTypedArray._c;
-
-  try {
-    // @ts-ignore
-    const typedArray: ArrayBufferView = new globalThis[constructorName](
-      arrayBuffer,
-    );
-    return new File([typedArray], "file", {
-      type: "application/octet-stream",
-    });
-  } catch (e) {}
-  return undefined;
-};
+  // Typed array
+  const arrayBuffer = decode(value.value);
+  if (TYPED_ARRAY_NAMES.has(_c)) {
+    try {
+      // @ts-ignore
+      return new globalThis[_c](arrayBuffer);
+    } catch (_) {}
+  }
+  return value;
+}