hbsig 0.3.2 → 0.3.3

package/.babelrc-cjs

@@ -0,0 +1,5 @@
+{
+  "presets": [
+    ["@babel/preset-env", { "modules": "commonjs" }]
+  ]
+}

package/.babelrc-esm

@@ -0,0 +1,5 @@
+{
+  "presets": [
+    ["@babel/preset-env", { "modules": false }]
+  ]
+}

package/README.md

@@ -0,0 +1 @@
+[Documentation](../docs/docs/pages/api/hbsig.mdx)

package/dist/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "hbsig",
+  "version": "0.3.1",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "require": "./cjs/index.js",
+      "import": "./esm/index.js"
+    },
+    "./nocrypto": {
+      "require": "./cjs/nocrypto.js",
+      "import": "./esm/nocrypto.js"
+    }
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.24.8",
+    "@babel/core": "^7.25.2",
+    "@babel/plugin-transform-modules-commonjs": "^7.24.8",
+    "@babel/preset-env": "^7.25.3",
+    "wao": "^0.33.0"
+  },
+  "dependencies": {
+    "@permaweb/aoconnect": "^0.0.85",
+    "base64url": "^3.0.1",
+    "fast-sha256": "^1.3.0",
+    "hbsig": "^0.1.5",
+    "ramda": "^0.31.3",
+    "structured-headers": "1.0.1"
+  },
+  "bin": {
+    "wao": "./cjs/cli.js",
+    "wao-esm": "./esm/cli.js"
+  },
+  "scripts": {
+    "server": "node --experimental-wasm-memory64 cjs/run.js"
+  }
+}

package/make.js

@@ -0,0 +1,36 @@
+import { writeFileSync, readFileSync } from "fs"
+import { resolve } from "path"
+
+const packageJson = resolve(import.meta.dirname, "package.json")
+const packageJsonDist = resolve(import.meta.dirname, "dist/package.json")
+const packageJsonDist2 = resolve(import.meta.dirname, "dist/esm/package.json")
+const json = JSON.parse(readFileSync(packageJson, "utf8"))
+delete json.type
+delete json.scripts
+json.main = "cjs/index.js"
+json.module = "esm/index.js"
+// Fix exports paths for dist package (remove dist/ prefix)
+json.exports = {
+  ".": {
+    "require": "./cjs/index.js",
+    "import": "./esm/index.js"
+  },
+  "./nocrypto": {
+    "require": "./cjs/nocrypto.js",
+    "import": "./esm/nocrypto.js"
+  }
+}
+json.bin = {
+  wao: "./cjs/cli.js",
+  "wao-esm": "./esm/cli.js",
+}
+json.scripts = {
+  server: "node --experimental-wasm-memory64 cjs/run.js",
+}
+
+writeFileSync(packageJsonDist, JSON.stringify(json, undefined, 2))
+
+const json2 = {
+  type: "module",
+}
+writeFileSync(packageJsonDist2, JSON.stringify(json2, undefined, 2))

package/package.json

@@ -1,17 +1,25 @@
 {
   "name": "hbsig",
-  "version": "0.3.2",
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
+  "version": "0.3.3",
+  "type": "module",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "scripts": {
+    "build:cjs": "babel src --out-dir dist/cjs --config-file ./.babelrc-cjs",
+    "build": "rm -rf dist && npm run build:cjs && cp src -rf dist/esm && node make.js && cp .npmignore dist/",
+    "test": "node --test --test-concurrency=1",
+    "test-only": "node --test-only --test-concurrency=1",
+    "test-all": "node --test --test-concurrency=1 test/**/*.test.js"
+  },
   "license": "MIT",
   "exports": {
     ".": {
-      "require": "./cjs/index.js",
-      "import": "./esm/index.js"
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js"
     },
     "./nocrypto": {
-      "require": "./cjs/nocrypto.js",
-      "import": "./esm/nocrypto.js"
+      "require": "./dist/cjs/nocrypto.js",
+      "import": "./dist/esm/nocrypto.js"
     }
   },
   "devDependencies": {
@@ -25,16 +33,7 @@
     "@permaweb/aoconnect": "^0.0.85",
     "base64url": "^3.0.1",
     "fast-sha256": "^1.3.0",
-    "hbsig": "^0.1.5",
     "ramda": "^0.31.3",
     "structured-headers": "1.0.1"
-  },
-  "bin": {
-    "wao": "./cjs/cli.js",
-    "wao-esm": "./esm/cli.js"
-  },
-  "scripts": {
-    "server": "node --experimental-wasm-memory64 cjs/run.js",
-    "preinstall": "./bin/install-deps"
   }
-}
+}

package/src/bin_to_str.js

@@ -0,0 +1,46 @@
+/**
+ * Convert a Buffer to string if it contains valid UTF-8 text
+ * @param {Buffer} buffer - Buffer to check and potentially convert
+ * @returns {string|Buffer} - String if valid UTF-8, otherwise original Buffer
+ */
+export default function bin_to_str(buffer) {
+  if (!Buffer.isBuffer(buffer)) {
+    return buffer
+  }
+
+  // Empty buffer stays as buffer
+  if (buffer.length === 0) {
+    return buffer
+  }
+
+  try {
+    const str = buffer.toString("utf8")
+    // Check if it's valid UTF-8 by seeing if it round-trips correctly
+    if (Buffer.from(str, "utf8").equals(buffer)) {
+      // Additional check: ensure all characters are printable or common whitespace
+      // This prevents converting binary data that happens to be valid UTF-8
+      let isPrintable = true
+      for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i)
+        // Allow printable ASCII (32-126) and common whitespace (tab, newline, carriage return)
+        if (
+          !(code >= 32 && code <= 126) &&
+          code !== 9 &&
+          code !== 10 &&
+          code !== 13
+        ) {
+          isPrintable = false
+          break
+        }
+      }
+
+      if (isPrintable) {
+        return str
+      }
+    }
+  } catch (e) {
+    // Not valid UTF-8, return original buffer
+  }
+
+  return buffer
+}

package/src/collect-body-keys.js

@@ -0,0 +1,436 @@
+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
+}
+
+const canArrayBeInHeader = array => {
+  // Empty arrays can be in headers
+  if (array.length === 0) return true
+
+  // Arrays with objects must go to body
+  if (array.some(item => isPojo(item))) return false
+
+  // Arrays with binary data must go to body
+  if (array.some(item => isBytes(item) && item.length > 0)) return false
+
+  // Arrays with non-ASCII strings must go to body
+  if (array.some(item => typeof item === "string" && hasNonAscii(item)))
+    return false
+
+  // Arrays with nested arrays must go to body (to match original behavior)
+  if (array.some(item => Array.isArray(item))) return false
+
+  // Arrays with nested arrays that have objects must go to body
+  if (
+    array.some(
+      item => Array.isArray(item) && item.some(subItem => isPojo(subItem))
+    )
+  )
+    return false
+
+  // Simple arrays of primitives can stay in headers
+  return true
+}
+
+// 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) {
+        // Check if array can stay in header
+        if (!canArrayBeInHeader(value)) {
+          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
+            // Only add to keys if array can't be in header
+            if (!canArrayBeInHeader(value)) {
+              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()
+}