wao 0.27.2 → 0.27.4

package/esm/collect-body-keys.js

@@ -0,0 +1,401 @@
+import {
+  hasNonAscii,
+  sha256,
+  hasNewline,
+  isBytes,
+  isPojo,
+} from "./encode-utils.js"
+
+// Helper functions
+const isEmpty = value => {
+  if (typeof value === "string") return value === ""
+  if (Array.isArray(value)) return value.length === 0
+  if (isPojo(value)) return Object.keys(value).length === 0
+  if (isBytes(value)) return value.length === 0 || value.byteLength === 0
+  return false
+}
+
+const hasOnlyEmptyValues = obj => {
+  if (!isPojo(obj)) return false
+  return Object.values(obj).every(
+    v =>
+      (typeof v === "string" && v === "") ||
+      (Array.isArray(v) && v.length === 0) ||
+      (isPojo(v) && Object.keys(v).length === 0)
+  )
+}
+
+const isSimpleValue = value => {
+  return (
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean" ||
+    value === null ||
+    value === undefined ||
+    typeof value === "symbol"
+  )
+}
+
+const getValueByPath = (obj, path) => {
+  const parts = path.split("/")
+  let value = obj
+  for (const part of parts) {
+    if (/^\d+$/.test(part)) {
+      value = value[parseInt(part) - 1]
+    } else {
+      value = value[part]
+    }
+  }
+  return value
+}
+
+// Array analysis helper
+const analyzeArray = array => {
+  const analysis = {
+    hasObjects: false,
+    hasArrays: false,
+    hasNonObjects: false,
+    hasArraysOfObjects: false,
+    hasEmptyStrings: false,
+    hasEmptyObjects: false,
+    hasNonEmptyObjects: false,
+    hasObjectsWithOnlyEmptyValues: false,
+    hasOnlyEmptyElements: true,
+  }
+
+  for (const item of array) {
+    if (isPojo(item)) {
+      analysis.hasObjects = true
+      if (Object.keys(item).length === 0) {
+        analysis.hasEmptyObjects = true
+      } else {
+        analysis.hasNonEmptyObjects = true
+        if (hasOnlyEmptyValues(item)) {
+          analysis.hasObjectsWithOnlyEmptyValues = true
+        }
+      }
+    } else if (Array.isArray(item)) {
+      analysis.hasArrays = true
+      if (item.some(subItem => isPojo(subItem))) {
+        analysis.hasArraysOfObjects = true
+      }
+    } else {
+      analysis.hasNonObjects = true
+    }
+
+    if (typeof item === "string" && item === "") {
+      analysis.hasEmptyStrings = true
+    }
+
+    if (!isEmpty(item)) {
+      analysis.hasOnlyEmptyElements = false
+    }
+  }
+
+  return analysis
+}
+
+// Body key collector class
+class BodyKeyCollector {
+  constructor(obj) {
+    this.obj = obj
+    this.keys = []
+  }
+
+  collect() {
+    this.processRootObject()
+    return this.deduplicateAndFilter()
+  }
+
+  // Process top-level object
+  processRootObject() {
+    const objKeys = Object.keys(this.obj)
+
+    for (const [key, value] of Object.entries(this.obj)) {
+      if (this.isSpecialDataBodyField(key, value, objKeys)) {
+        this.keys.push(key)
+      } else if (Array.isArray(value) && value.length > 0) {
+        this.processRootArray(key, value)
+      } else if (isPojo(value)) {
+        this.processRootNestedObject(key, value)
+      } else if (this.needsBodyKey(key, value)) {
+        this.keys.push(key)
+      }
+    }
+  }
+
+  // Check if field is special data/body field
+  isSpecialDataBodyField(key, value, objKeys) {
+    if (
+      (key === "data" || key === "body") &&
+      isSimpleValue(value) &&
+      objKeys.length > 1
+    ) {
+      const otherKey = key === "data" ? "body" : "data"
+      const otherValue = this.obj[otherKey]
+
+      if (
+        otherValue &&
+        isPojo(otherValue) &&
+        Object.keys(otherValue).length > 0
+      ) {
+        return false
+      }
+      return true
+    }
+    return false
+  }
+
+  // Check if value needs a body key
+  needsBodyKey(key, value) {
+    return (
+      (isBytes(value) && value.length > 0) ||
+      (typeof value === "string" && value.includes("\n")) ||
+      (typeof value === "string" && hasNonAscii(value))
+    )
+  }
+
+  // Process root-level arrays
+  processRootArray(key, array) {
+    const analysis = analyzeArray(array)
+    let bodyPartCounter = 1
+
+    if (analysis.hasArraysOfObjects) {
+      // Handle arrays of arrays containing objects
+      array.forEach((item, index) => {
+        if (Array.isArray(item)) {
+          item.forEach((subItem, subIndex) => {
+            if (isPojo(subItem)) {
+              this.keys.push(`${key}/${index + 1}/${subIndex + 1}`)
+            }
+          })
+        }
+      })
+      this.keys.push(key)
+    } else if (
+      analysis.hasObjects &&
+      (analysis.hasEmptyStrings || analysis.hasEmptyObjects) &&
+      !analysis.hasObjectsWithOnlyEmptyValues
+    ) {
+      // Mixed array: only non-empty objects get parts
+      array.forEach(item => {
+        if (isPojo(item) && Object.keys(item).length > 0) {
+          const path = `${key}/${bodyPartCounter}`
+          this.keys.push(path)
+          this.addNestedObjectPaths(item, path)
+        }
+        bodyPartCounter++
+      })
+      this.keys.push(key)
+    } else if (analysis.hasObjects) {
+      // Regular array with objects
+      const skipEmptyObjects = analysis.hasOnlyEmptyElements
+
+      array.forEach(item => {
+        if (isPojo(item)) {
+          if (!(skipEmptyObjects && Object.keys(item).length === 0)) {
+            const path = `${key}/${bodyPartCounter}`
+            this.keys.push(path)
+            if (Object.keys(item).length > 0) {
+              this.addNestedObjectPaths(item, path)
+            }
+          }
+        } else if (typeof item === "string" && item === "") {
+          this.keys.push(`${key}/${bodyPartCounter}`)
+        }
+        bodyPartCounter++
+      })
+
+      // Add main array key conditionally
+      if (!analysis.hasObjectsWithOnlyEmptyValues || analysis.hasNonObjects) {
+        if (!analysis.hasOnlyEmptyElements) {
+          this.keys.push(key)
+        }
+      }
+    } else {
+      // Simple array without objects
+      const hasOnlyEmptyArraysOrObjects = array.every(
+        item =>
+          isEmpty(item) &&
+          (Array.isArray(item) || isPojo(item) || typeof item === "string")
+      )
+
+      if (hasOnlyEmptyArraysOrObjects || !array.every(isEmpty)) {
+        this.keys.push(key)
+      }
+    }
+  }
+
+  // Add paths for nested objects within an object
+  addNestedObjectPaths(obj, basePath) {
+    for (const [nestedKey, nestedValue] of Object.entries(obj)) {
+      if (isPojo(nestedValue) && Object.keys(nestedValue).length > 0) {
+        this.keys.push(`${basePath}/${nestedKey}`)
+      }
+    }
+  }
+
+  // Process root-level nested object
+  processRootNestedObject(key, obj) {
+    // Check for arrays with only empty elements
+    for (const [k, v] of Object.entries(obj)) {
+      if (Array.isArray(v) && v.length > 0 && v.every(isEmpty)) {
+        this.keys.push(`${key}/${k}`)
+      }
+    }
+
+    // Traverse the object
+    this.traverse(obj, key)
+  }
+
+  // Traverse nested structures
+  traverse(current, path) {
+    let hasSimpleFields = false
+    const nestedPaths = []
+    let hasArraysWithObjects = false
+
+    // First pass: analyze structure
+    for (const [key, value] of Object.entries(current)) {
+      const fullPath = path ? `${path}/${key}` : key
+      const result = this.analyzeFieldInTraversal(value, fullPath, nestedPaths)
+
+      hasSimpleFields = hasSimpleFields || result.hasSimpleFields
+      hasArraysWithObjects = hasArraysWithObjects || result.hasArraysWithObjects
+    }
+
+    // Add current path if needed
+    if (hasSimpleFields || (hasArraysWithObjects && path)) {
+      this.keys.push(path)
+    }
+
+    // Second pass: check for arrays with only empty elements
+    for (const [key, value] of Object.entries(current)) {
+      const fullPath = path ? `${path}/${key}` : key
+      if (Array.isArray(value) && value.length > 0 && value.every(isEmpty)) {
+        this.keys.push(fullPath)
+      }
+    }
+
+    // Traverse nested objects
+    for (const nestedPath of nestedPaths) {
+      const nestedObj = getValueByPath(this.obj, nestedPath)
+      if (isPojo(nestedObj)) {
+        this.traverse(nestedObj, nestedPath)
+      }
+    }
+  }
+
+  // Analyze a field during traversal
+  analyzeFieldInTraversal(value, fullPath, nestedPaths) {
+    let hasSimpleFields = false
+    let hasArraysWithObjects = false
+
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        hasSimpleFields = true
+      } else {
+        const analysis = analyzeArray(value)
+
+        if (analysis.hasObjects) {
+          hasArraysWithObjects = true
+          this.processArrayInTraversal(value, fullPath, nestedPaths, analysis)
+
+          if (analysis.hasNonObjects) {
+            hasSimpleFields = true
+            this.keys.push(fullPath)
+          }
+        } else {
+          hasSimpleFields = true
+        }
+      }
+    } else if (isPojo(value)) {
+      if (Object.keys(value).length === 0) {
+        hasSimpleFields = true
+      } else if (hasOnlyEmptyValues(value)) {
+        this.keys.push(fullPath)
+      } else {
+        const hasArraysWithOnlyEmptyElements = Object.entries(value).some(
+          ([k, v]) => Array.isArray(v) && v.length > 0 && v.every(isEmpty)
+        )
+
+        if (hasArraysWithOnlyEmptyElements) {
+          this.keys.push(fullPath)
+        }
+        nestedPaths.push(fullPath)
+      }
+    } else if ((isBytes(value) && value.length > 0) || isSimpleValue(value)) {
+      hasSimpleFields = true
+    }
+
+    return { hasSimpleFields, hasArraysWithObjects }
+  }
+
+  // Process arrays found during traversal
+  processArrayInTraversal(array, fullPath, nestedPaths, analysis) {
+    if (
+      (analysis.hasEmptyStrings || analysis.hasEmptyObjects) &&
+      analysis.hasNonEmptyObjects
+    ) {
+      // Special case: only non-empty objects get parts
+      array.forEach((item, index) => {
+        if (isPojo(item) && Object.keys(item).length > 0) {
+          const itemPath = `${fullPath}/${index + 1}`
+          this.keys.push(itemPath)
+          nestedPaths.push(itemPath)
+        }
+      })
+    } else if (
+      analysis.hasObjectsWithOnlyEmptyValues &&
+      !analysis.hasNonObjects
+    ) {
+      // Objects with only empty values
+      array.forEach((item, index) => {
+        if (isPojo(item)) {
+          const itemPath = `${fullPath}/${index + 1}`
+          this.keys.push(itemPath)
+          if (Object.keys(item).length > 0) {
+            nestedPaths.push(itemPath)
+          }
+        }
+      })
+    } else {
+      // Normal case
+      array.forEach((item, index) => {
+        if (isPojo(item)) {
+          const itemPath = `${fullPath}/${index + 1}`
+          this.keys.push(itemPath)
+          if (Object.keys(item).length > 0) {
+            nestedPaths.push(itemPath)
+          }
+        }
+      })
+    }
+  }
+
+  // Deduplicate and filter results
+  deduplicateAndFilter() {
+    const uniqueKeys = [...new Set(this.keys)]
+
+    return uniqueKeys.filter(k => {
+      if (!k) return false
+
+      // Check if this is a path to an element inside an array with only empty elements
+      const parts = k.split("/")
+      if (parts.length >= 2 && /^\d+$/.test(parts[parts.length - 1])) {
+        const arrayPath = parts.slice(0, -1).join("/")
+        const arrayValue = getValueByPath(this.obj, arrayPath)
+
+        if (Array.isArray(arrayValue) && arrayValue.every(isEmpty)) {
+          return false
+        }
+      }
+
+      return true
+    })
+  }
+}
+
+export default function collectBodyKeys(obj, prefix = "") {
+  const collector = new BodyKeyCollector(obj)
+  return collector.collect()
+}

package/esm/encode-array-item.js

@@ -0,0 +1,112 @@
+import { toBuffer, formatFloat, isBytes, isPojo } from "./encode-utils.js"
+
+// Helper to generate the correct number of backslashes for a given nesting level
+function getBackslashes(level) {
+  return "\\".repeat(Math.pow(2, level) - 1)
+}
+
+// Helper to encode primitive values at a specific nesting level
+function encodePrimitiveAtLevel(value, level) {
+  const bs = getBackslashes(level)
+
+  if (typeof value === "number") {
+    if (Number.isInteger(value)) {
+      return `${bs}"(ao-type-integer) ${value}${bs}"`
+    } else {
+      return `${bs}"(ao-type-float) ${formatFloat(value)}${bs}"`
+    }
+  } else if (typeof value === "string") {
+    return `${bs}"${value}${bs}"`
+  } else if (value === null) {
+    const innerBs = getBackslashes(level + 1)
+    return `${bs}"(ao-type-atom) ${innerBs}"null${innerBs}"${bs}"`
+  } else if (value === undefined) {
+    const innerBs = getBackslashes(level + 1)
+    return `${bs}"(ao-type-atom) ${innerBs}"undefined${innerBs}"${bs}"`
+  } else if (typeof value === "symbol") {
+    const desc = value.description || "Symbol.for()"
+    const innerBs = getBackslashes(level + 1)
+    return `${bs}"(ao-type-atom) ${innerBs}"${desc}${innerBs}"${bs}"`
+  } else if (typeof value === "boolean") {
+    const innerBs = getBackslashes(level + 1)
+    return `${bs}"(ao-type-atom) ${innerBs}"${value}${innerBs}"${bs}"`
+  } else {
+    return `${bs}"${String(value)}${bs}"`
+  }
+}
+
+// Recursive function to handle arrays at any nesting level
+function encodeArrayAtLevel(items, level) {
+  // The original code only goes 3 levels deep for arrays
+  if (level >= 3) {
+    const bs = getBackslashes(level)
+    const stringItems = items
+      .map(item => {
+        if (typeof item === "number") {
+          if (Number.isInteger(item)) {
+            return `${bs}"(ao-type-integer) ${item}${bs}"`
+          } else {
+            return `${bs}"(ao-type-float) ${formatFloat(item)}${bs}"`
+          }
+        } else if (typeof item === "string") {
+          return `${bs}"${item}${bs}"`
+        } else {
+          return `${bs}"${String(item)}${bs}"`
+        }
+      })
+      .join(", ")
+    return `${getBackslashes(level - 1)}"(ao-type-list) ${stringItems}${getBackslashes(level - 1)}"`
+  }
+
+  const encodedItems = items
+    .map(item => {
+      if (Array.isArray(item)) {
+        return encodeArrayAtLevel(item, level + 1)
+      } else {
+        return encodePrimitiveAtLevel(item, level)
+      }
+    })
+    .join(", ")
+
+  if (level === 0) {
+    return `"(ao-type-list) ${encodedItems}"`
+  } else {
+    const bs = getBackslashes(level - 1)
+    return `${bs}"(ao-type-list) ${encodedItems}${bs}"`
+  }
+}
+
+export default function encodeArrayItem(item) {
+  if (typeof item === "number") {
+    if (Number.isInteger(item)) {
+      return `"(ao-type-integer) ${item}"`
+    } else {
+      return `"(ao-type-float) ${formatFloat(item)}"`
+    }
+  } else if (typeof item === "string") {
+    return `"${item}"`
+  } else if (item === null) {
+    return `"(ao-type-atom) \\"null\\""`
+  } else if (item === undefined) {
+    return `"(ao-type-atom) \\"undefined\\""`
+  } else if (typeof item === "symbol") {
+    const desc = item.description || "Symbol.for()"
+    return `"(ao-type-atom) \\"${desc}\\""`
+  } else if (typeof item === "boolean") {
+    return `"(ao-type-atom) \\"${item}\\""`
+  } else if (Array.isArray(item)) {
+    return encodeArrayAtLevel(item, 1)
+  } else if (isBytes(item)) {
+    const buffer = toBuffer(item)
+    if (buffer.length === 0 || buffer.byteLength === 0) {
+      return `""`
+    }
+    return `"(ao-type-binary)"`
+  } else if (isPojo(item)) {
+    const json = JSON.stringify(item)
+    const escaped = json.replace(/\\/g, "\\\\").replace(/"/g, '\\"')
+    return `"(ao-type-map) ${escaped}"`
+  } else {
+    return `"${String(item)}"`
+  }
+}

package/esm/encode-utils.js

@@ -0,0 +1,185 @@
+import { hash } from "fast-sha256"
+
+export function isBytes(value) {
+  return (
+    value instanceof ArrayBuffer ||
+    ArrayBuffer.isView(value) ||
+    Buffer.isBuffer(value) ||
+    (value &&
+      typeof value === "object" &&
+      value.type === "Buffer" &&
+      Array.isArray(value.data))
+  )
+}
+
+export function isPojo(value) {
+  return (
+    !isBytes(value) &&
+    !Array.isArray(value) &&
+    !(value instanceof Blob) &&
+    typeof value === "object" &&
+    value !== null
+  )
+}
+
+export async function hasNewline(value) {
+  if (typeof value === "string") return value.includes("\n")
+  if (value instanceof Blob) {
+    value = await value.text()
+    return value.includes("\n")
+  }
+  if (isBytes(value)) return Buffer.from(value).includes("\n")
+  return false
+}
+
+export async function sha256(data) {
+  let uint8Array
+  if (data instanceof ArrayBuffer) {
+    uint8Array = new Uint8Array(data)
+  } else if (data instanceof Uint8Array) {
+    uint8Array = data
+  } else if (ArrayBuffer.isView(data)) {
+    uint8Array = new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+  } else {
+    throw new Error("sha256 expects ArrayBuffer or ArrayBufferView")
+  }
+
+  const hashResult = hash(uint8Array)
+  return hashResult.buffer.slice(
+    hashResult.byteOffset,
+    hashResult.byteOffset + hashResult.byteLength
+  )
+}
+
+export function formatFloat(num) {
+  let exp = num.toExponential(20)
+  exp = exp.replace(/e\+(\d)$/, "e+0$1")
+  exp = exp.replace(/e-(\d)$/, "e-0$1")
+  return exp
+}
+
+export function hasNonAscii(str) {
+  return /[^\x00-\x7F]/.test(str)
+}
+
+export function toBuffer(value) {
+  if (Buffer.isBuffer(value)) {
+    return value
+  } else if (
+    value &&
+    typeof value === "object" &&
+    value.type === "Buffer" &&
+    Array.isArray(value.data)
+  ) {
+    return Buffer.from(value.data)
+  } else if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    return Buffer.from(value)
+  } else {
+    return Buffer.from(value)
+  }
+}
+
+// Navigate through a path to get a value from nested object/array
+export function getValueByPath(obj, path) {
+  const pathParts = path.split("/")
+  let value = obj
+  for (const part of pathParts) {
+    if (/^\d+$/.test(part)) {
+      value = value[parseInt(part) - 1]
+    } else {
+      value = value[part]
+    }
+  }
+  return value
+}
+
+// Get the ao-type for a value
+export function getAoType(value) {
+  if (
+    typeof value === "boolean" ||
+    value === null ||
+    value === undefined ||
+    typeof value === "symbol"
+  ) {
+    return "atom"
+  } else if (typeof value === "number") {
+    return Number.isInteger(value) ? "integer" : "float"
+  } else if (typeof value === "string" && value.length === 0) {
+    return "empty-binary"
+  } else if (isBytes(value) && (value.length === 0 || value.byteLength === 0)) {
+    return "empty-binary"
+  } else if (Array.isArray(value) && value.length === 0) {
+    return "empty-list"
+  } else if (Array.isArray(value)) {
+    return "list"
+  } else if (isPojo(value) && Object.keys(value).length === 0) {
+    return "empty-message"
+  }
+  return null
+}
+
+// Check if a value is empty
+export function isEmpty(value) {
+  return (
+    (Array.isArray(value) && value.length === 0) ||
+    (isPojo(value) && Object.keys(value).length === 0) ||
+    (isBytes(value) && (value.length === 0 || value.byteLength === 0)) ||
+    (typeof value === "string" && value.length === 0)
+  )
+}
+
+// Convert primitive values to their encoded string representation
+export function encodePrimitiveContent(value) {
+  if (typeof value === "string") {
+    return value
+  } else if (typeof value === "boolean") {
+    return `"${value}"`
+  } else if (typeof value === "number") {
+    return String(value)
+  } else if (value === null) {
+    return '"null"'
+  } else if (value === undefined) {
+    return '"undefined"'
+  } else if (typeof value === "symbol") {
+    return `"${value.description || "Symbol.for()"}"`
+  }
+  return value
+}
+
+// Sort type annotations by their numeric prefix
+export function sortTypeAnnotations(types) {
+  return types.sort((a, b) => {
+    const aNum = parseInt(a.split("=")[0])
+    const bNum = parseInt(b.split("=")[0])
+    return aNum - bNum
+  })
+}
+
+// Analyze array contents
+export function analyzeArray(array) {
+  return {
+    hasObjects: array.some(item => isPojo(item)),
+    hasArrays: array.some(item => Array.isArray(item)),
+    hasEmptyStrings: array.some(
+      item => typeof item === "string" && item === ""
+    ),
+    hasEmptyObjects: array.some(
+      item => isPojo(item) && Object.keys(item).length === 0
+    ),
+    hasOnlyEmptyElements:
+      array.length > 0 &&
+      array.every(
+        item =>
+          (Array.isArray(item) && item.length === 0) ||
+          (isPojo(item) && Object.keys(item).length === 0) ||
+          (typeof item === "string" && item === "")
+      ),
+    hasOnlyNonEmptyObjects:
+      array.length > 0 &&
+      array.every(item => isPojo(item) && Object.keys(item).length > 0),
+    hasObjectsWithOnlyEmptyValues: array.some(item => {
+      if (!isPojo(item) || Object.keys(item).length === 0) return false
+      return Object.values(item).every(v => isEmpty(v))
+    }),
+  }
+}