@ic-reactor/candid 3.0.2-beta.0 → 3.0.2

package/src/visitor/helpers.test.ts

@@ -0,0 +1,274 @@
+import { describe, it, expect } from "vitest"
+import {
+  isPrincipalId,
+  isCanisterId,
+  isBtcAddress,
+  isEthAddress,
+  isAccountIdentifier,
+  isIsoDate,
+  isUrl,
+  isImage,
+  isUuid,
+} from "./helpers"
+
+describe("Helpers", () => {
+  describe("isPrincipalId", () => {
+    it("should return true for valid principal IDs", () => {
+      expect(isPrincipalId("aaaaa-aa")).toBe(true)
+      expect(isPrincipalId("2vxsx-fae")).toBe(true)
+      expect(isPrincipalId("rrkah-fqaaa-aaaaa-aaaaq-cai")).toBe(true)
+    })
+
+    it("should return false for invalid principal IDs", () => {
+      expect(isPrincipalId("")).toBe(false) // empty string
+      expect(isPrincipalId("invalid-principal")).toBe(false) // contains invalid characters
+      expect(isPrincipalId("123456")).toBe(false) // numbers only
+      expect(
+        isPrincipalId("a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0u1v2w3x4y5z")
+      ).toBe(false) // too long
+      expect(isPrincipalId("not-a-valid-principal")).toBe(false) // malformed
+    })
+
+    it("should return false for non-string inputs", () => {
+      expect(isPrincipalId(123 as any)).toBe(false)
+      expect(isPrincipalId(null as any)).toBe(false)
+      expect(isPrincipalId(undefined as any)).toBe(false)
+      expect(isPrincipalId({} as any)).toBe(false)
+    })
+  })
+
+  describe("isCanisterId", () => {
+    it("should return true for valid canister IDs", () => {
+      expect(isCanisterId("rrkah-fqaaa-aaaaa-aaaaq-cai")).toBe(true)
+      expect(isCanisterId("ryjl3-tyaaa-aaaaa-aaaba-cai")).toBe(true)
+    })
+
+    it("should return false for principal IDs that are not canister IDs", () => {
+      expect(isCanisterId("aaaaa-aa")).toBe(false) // too short
+      expect(isCanisterId("2vxsx-fae")).toBe(false) // too short
+    })
+
+    it("should return false for invalid strings", () => {
+      expect(isCanisterId("invalid-canister-id")).toBe(false)
+      expect(isCanisterId("rrkah-fqaaa-aaaaa-aaaaq")).toBe(false) // missing -cai
+      expect(isCanisterId("rrkah-fqaaa-aaaaa-aaaaq-ca")).toBe(false) // wrong ending
+      expect(isCanisterId("")).toBe(false)
+    })
+
+    it("should return false for non-string inputs", () => {
+      expect(isCanisterId(123 as any)).toBe(false)
+      expect(isCanisterId(null as any)).toBe(false)
+    })
+  })
+
+  describe("isBtcAddress", () => {
+    it("should return true for valid Bitcoin addresses", () => {
+      // Bech32 mainnet
+      expect(isBtcAddress("bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4")).toBe(
+        true
+      )
+      // Bech32 testnet
+      expect(isBtcAddress("tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx")).toBe(
+        true
+      )
+      // Base58 mainnet
+      expect(isBtcAddress("1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2")).toBe(true)
+      // Base58 testnet
+      expect(isBtcAddress("mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn")).toBe(true)
+    })
+
+    it("should return false for invalid Bitcoin addresses", () => {
+      expect(isBtcAddress("")).toBe(false)
+      expect(isBtcAddress("invalid")).toBe(false)
+      expect(isBtcAddress("bc1short")).toBe(false) // too short
+      expect(
+        isBtcAddress(
+          "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4"
+        )
+      ).toBe(false) // too long
+    })
+
+    it("should return false for non-string inputs", () => {
+      expect(isBtcAddress(123 as any)).toBe(false)
+      expect(isBtcAddress(null as any)).toBe(false)
+    })
+  })
+
+  describe("isEthAddress", () => {
+    it("should return true for valid Ethereum addresses", () => {
+      expect(isEthAddress("0x742d35Cc6634C0532925a3b844Bc454e4438f44e")).toBe(
+        true
+      )
+      expect(isEthAddress("0x742d35cc6634c0532925a3b844bc454e4438f44e")).toBe(
+        true
+      ) // lowercase
+      expect(isEthAddress("0x742D35CC6634C0532925A3B844BC454E4438F44E")).toBe(
+        true
+      ) // uppercase
+    })
+
+    it("should return false for invalid Ethereum addresses", () => {
+      expect(isEthAddress("")).toBe(false)
+      expect(isEthAddress("0x742d35Cc6634C0532925a3b844Bc454e4438f44")).toBe(
+        false
+      ) // too short
+      expect(isEthAddress("0x742d35Cc6634C0532925a3b844Bc454e4438f44ee")).toBe(
+        false
+      ) // too long
+      expect(isEthAddress("742d35Cc6634C0532925a3b844Bc454e4438f44e")).toBe(
+        false
+      ) // missing 0x
+      expect(isEthAddress("0x742d35Cc6634C0532925a3b844Bc454e4438f44g")).toBe(
+        false
+      ) // invalid char
+    })
+
+    it("should return false for non-string inputs", () => {
+      expect(isEthAddress(123 as any)).toBe(false)
+      expect(isEthAddress(null as any)).toBe(false)
+    })
+  })
+
+  describe("isAccountIdentifier", () => {
+    it("should return true for valid account identifiers", () => {
+      expect(
+        isAccountIdentifier(
+          "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1"
+        )
+      ).toBe(true)
+      expect(
+        isAccountIdentifier(
+          "0000000000000000000000000000000000000000000000000000000000000000"
+        )
+      ).toBe(true)
+      expect(
+        isAccountIdentifier(
+          "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+        )
+      ).toBe(true)
+    })
+
+    it("should return false for invalid account identifiers", () => {
+      expect(isAccountIdentifier("")).toBe(false)
+      expect(
+        isAccountIdentifier(
+          "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1"
+        )
+      ).toBe(false) // 63 chars
+      expect(
+        isAccountIdentifier(
+          "a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a"
+        )
+      ).toBe(false) // 65 chars
+      expect(
+        isAccountIdentifier(
+          "gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg"
+        )
+      ).toBe(false) // invalid chars
+    })
+
+    it("should return false for non-string inputs", () => {
+      expect(isAccountIdentifier(123 as any)).toBe(false)
+      expect(isAccountIdentifier(null as any)).toBe(false)
+    })
+  })
+
+  describe("isIsoDate", () => {
+    it("should return true for valid ISO dates", () => {
+      expect(isIsoDate("2023-12-25T10:30:00Z")).toBe(true)
+      expect(isIsoDate("2023-12-25T10:30:00.123Z")).toBe(true)
+      expect(isIsoDate("2023-12-25T10:30:00+05:30")).toBe(true)
+      expect(isIsoDate("2023-12-25T10:30:00-08:00")).toBe(true)
+    })
+
+    it("should return false for invalid ISO dates", () => {
+      expect(isIsoDate("")).toBe(false)
+      expect(isIsoDate("2023-12-25")).toBe(false) // missing time
+      expect(isIsoDate("2023-12-25T10:30:00")).toBe(false) // missing timezone
+      expect(isIsoDate("invalid-date")).toBe(false)
+      expect(isIsoDate("2023-12-25T10:30:00Zextra")).toBe(false) // extra characters
+    })
+
+    it("should return false for non-string inputs", () => {
+      expect(isIsoDate(123 as any)).toBe(false)
+      expect(isIsoDate(null as any)).toBe(false)
+    })
+  })
+
+  describe("isUrl", () => {
+    it("should return true for valid URLs", () => {
+      expect(isUrl("http://example.com")).toBe(true)
+      expect(isUrl("https://example.com")).toBe(true)
+      expect(isUrl("https://example.com/path")).toBe(true)
+      expect(isUrl("https://example.com/path?query=value")).toBe(true)
+    })
+
+    it("should return false for invalid URLs", () => {
+      expect(isUrl("")).toBe(false)
+      expect(isUrl("example.com")).toBe(false) // missing protocol
+      expect(isUrl("ftp://example.com")).toBe(false) // unsupported protocol
+      expect(isUrl("not-a-url")).toBe(false)
+    })
+
+    it("should return false for non-string inputs", () => {
+      expect(isUrl(123 as any)).toBe(false)
+      expect(isUrl(null as any)).toBe(false)
+    })
+  })
+
+  describe("isImage", () => {
+    it("should return true for valid image URLs", () => {
+      expect(isImage("https://example.com/image.jpg")).toBe(true)
+      expect(isImage("https://example.com/image.jpeg")).toBe(true)
+      expect(isImage("https://example.com/image.png")).toBe(true)
+      expect(isImage("https://example.com/image.gif")).toBe(true)
+      expect(isImage("https://example.com/image.svg")).toBe(true)
+    })
+
+    it("should return true for base64 image data", () => {
+      expect(
+        isImage(
+          "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
+        )
+      ).toBe(true)
+      expect(
+        isImage(
+          "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAv/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAAX/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwA/vAA="
+        )
+      ).toBe(true)
+    })
+
+    it("should return false for non-image URLs", () => {
+      expect(isImage("https://example.com/document.pdf")).toBe(false)
+      expect(isImage("https://example.com/video.mp4")).toBe(false)
+      expect(isImage("not-an-image")).toBe(false)
+      expect(isImage("")).toBe(false)
+    })
+
+    it("should return false for non-string inputs", () => {
+      expect(isImage(123 as any)).toBe(false)
+      expect(isImage(null as any)).toBe(false)
+    })
+  })
+
+  describe("isUuid", () => {
+    it("should return true for valid UUIDs", () => {
+      expect(isUuid("123e4567-e89b-12d3-a456-426614174000")).toBe(true)
+      expect(isUuid("123E4567-E89B-12D3-A456-426614174000")).toBe(true) // uppercase
+      expect(isUuid("123e4567-e89b-12d3-a456-426614174000")).toBe(true) // lowercase
+    })
+
+    it("should return false for invalid UUIDs", () => {
+      expect(isUuid("")).toBe(false)
+      expect(isUuid("123e4567-e89b-12d3-a456-42661417400")).toBe(false) // too short
+      expect(isUuid("123e4567-e89b-12d3-a456-4266141740000")).toBe(false) // too long
+      expect(isUuid("123e4567-e89b-12d3-a456-42661417400g")).toBe(false) // invalid char
+      expect(isUuid("not-a-uuid")).toBe(false)
+    })
+
+    it("should return false for non-string inputs", () => {
+      expect(isUuid(123 as any)).toBe(false)
+      expect(isUuid(null as any)).toBe(false)
+    })
+  })
+})

package/src/visitor/helpers.ts

@@ -0,0 +1,223 @@
+import { IDL } from "@icp-sdk/core/candid"
+import { Principal } from "@icp-sdk/core/principal"
+
+export const extractAndSortArgs = <T extends Record<string, unknown>>(
+  argsObject: T
+): Array<T[keyof T]> => {
+  if (!argsObject || typeof argsObject !== "object") return []
+
+  const args: Array<T[keyof T]> = []
+  let index = 0
+
+  while (Object.prototype.hasOwnProperty.call(argsObject, `arg${index}`)) {
+    args.push(argsObject[`arg${index}`] as T[keyof T])
+    index++
+  }
+
+  return args
+}
+
+/**
+ * Normalize form state by converting objects with numeric string keys to arrays.
+ * TanStack Form sometimes creates { "0": value, "1": value } instead of [value, value]
+ * when using indexed field paths like "parent.0.child".
+ *
+ * This function also handles the variant cleanup case where objects have mixed
+ * numeric and named keys (e.g., { "0": old, "Add": current }) by removing
+ * orphaned numeric keys.
+ *
+ * This function recursively processes the form state and fixes these issues.
+ */
+export const normalizeFormState = <T>(value: T): T => {
+  // Handle null/undefined
+  if (value === null || value === undefined) {
+    return value
+  }
+
+  // Handle arrays - recursively normalize each element
+  if (Array.isArray(value)) {
+    return value.map(normalizeFormState) as T
+  }
+
+  // Handle objects
+  if (typeof value === "object") {
+    const obj = value as Record<string, unknown>
+    const keys = Object.keys(obj)
+
+    // Separate numeric and non-numeric keys
+    const numericKeys = keys.filter((k) => /^\d+$/.test(k))
+    const namedKeys = keys.filter((k) => !/^\d+$/.test(k))
+
+    // Case 1: All keys are numeric - convert to array
+    if (numericKeys.length > 0 && namedKeys.length === 0) {
+      const sortedNums = numericKeys.map(Number).sort((a, b) => a - b)
+      // Check if keys are consecutive starting from 0
+      if (sortedNums.every((num, idx) => num === idx)) {
+        return sortedNums.map((k) => normalizeFormState(obj[String(k)])) as T
+      }
+    }
+
+    // Case 2: Mixed keys (variant case) - keep only named keys, remove orphan numeric keys
+    if (numericKeys.length > 0 && namedKeys.length > 0) {
+      const result: Record<string, unknown> = {}
+      for (const key of namedKeys) {
+        result[key] = normalizeFormState(obj[key])
+      }
+      return result as T
+    }
+
+    // Case 3: All named keys - recursively normalize all values
+    const result: Record<string, unknown> = {}
+    for (const [key, val] of Object.entries(obj)) {
+      result[key] = normalizeFormState(val)
+    }
+    return result as T
+  }
+
+  // Return primitives as-is
+  return value
+}
+
+export const convertNanoToDate = (nano: bigint) => {
+  return new Date(Number(nano) / 1000000)
+}
+
+export const convertToCycle = (cycles: bigint) => {
+  const mcycles = cycles / BigInt(1_000_000)
+  if (mcycles >= BigInt(1_000_000)) {
+    const tcycles = mcycles / BigInt(1_000_000)
+    return `${tcycles.toLocaleString()} T`
+  }
+  return `${mcycles.toLocaleString()} M`
+}
+
+export const convertStringToNumber = (value: string) => {
+  const bits = value.length
+  if (bits >= 16) {
+    return BigInt(value)
+  } else {
+    return Number(value)
+  }
+}
+
+export const validateNumberError = (t: IDL.Type) => {
+  return function validate(value: string) {
+    if (value === "") {
+      return true
+    }
+
+    const bits = value.length
+    if (bits >= 16) {
+      try {
+        const valueAsBigInt = BigInt(value)
+        t.covariant(valueAsBigInt)
+        return true
+      } catch (error) {
+        return (error as Error).message || "Failed to convert to BigInt"
+      }
+    } else {
+      try {
+        const valueAsNumber = Number(value)
+        t.covariant(valueAsNumber)
+        return true
+      } catch (error) {
+        return (error as Error).message || "Failed to convert to number"
+      }
+    }
+  }
+}
+
+export const validateError = (t: IDL.Type) => {
+  return function validate(value: unknown) {
+    try {
+      t.covariant(value)
+      return true
+    } catch (error) {
+      return (error as Error).message || "An error occurred"
+    }
+  }
+}
+
+export function isQuery(func: IDL.FuncClass): boolean {
+  return (
+    func.annotations.includes("query") ||
+    func.annotations.includes("composite_query")
+  )
+}
+
+export function isUrl(str: string): boolean {
+  if (typeof str !== "string") return false
+  return str.startsWith("http") || str.startsWith("https")
+}
+
+export function isImage(str: string): boolean {
+  if (typeof str !== "string") return false
+  // Check if the string starts with 'data:image' (indicating base64-encoded image)
+  if (str.startsWith("data:image")) {
+    return true
+  }
+
+  // List of common image file extensions
+  const imageExtensions = [".jpg", ".jpeg", ".png", ".gif", ".svg"]
+
+  // Check if the string ends with any of the image extensions (indicating image URL)
+  if (imageExtensions.some((ext) => str.endsWith(ext))) {
+    return true
+  }
+
+  return false
+}
+
+export function isUuid(str: string): boolean {
+  if (typeof str !== "string") return false
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    str
+  )
+}
+
+export function isPrincipalId(str: string): boolean {
+  if (typeof str !== "string") return false
+  try {
+    Principal.fromText(str)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function isCanisterId(str: string): boolean {
+  if (typeof str !== "string") return false
+  if (!isPrincipalId(str)) return false
+  if (str.length !== 27) return false
+  // All canister IDs end with "-cai"
+  return str.endsWith("-cai")
+}
+
+export function isBtcAddress(str: string): boolean {
+  if (typeof str !== "string") return false
+  // Bech32 (Mainnet: bc1, Testnet: tb1, Regtest: bcrt1)
+  if (/^(bc1|tb1|bcrt1)[a-zA-HJ-NP-Z0-9]{25,60}$/.test(str)) return true
+  // Base58 (Mainnet: 1/3, Testnet: m/n/2)
+  if (/^[13mn2][a-km-zA-HJ-NP-Z1-9]{25,34}$/.test(str)) return true
+  return false
+}
+
+export function isEthAddress(str: string): boolean {
+  if (typeof str !== "string") return false
+  return /^0x[a-fA-F0-9]{40}$/.test(str)
+}
+
+export function isAccountIdentifier(str: string): boolean {
+  if (typeof str !== "string") return false
+  // 64 characters hex string (standard for ICP account ids and hashes)
+  return /^[a-fA-F0-9]{64}$/.test(str)
+}
+
+export function isIsoDate(str: string): boolean {
+  if (typeof str !== "string") return false
+  // Basic ISO 8601 / RFC 3339 format check
+  // YYYY-MM-DDTHH:mm:ss.sssZ (optional milliseconds/nanoseconds and timezone)
+  return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})$/.test(
+    str
+  )
+}

package/src/visitor/index.ts

@@ -0,0 +1,4 @@
+export * from "./returns"
+export * from "./arguments"
+export * from "./types"
+export * from "./helpers"