chore(papi): commit the sources behind the four polkadot-api packages (#15)

* chore(papi): commit the sources behind the four polkadot-api packages

papi-utils, bizinikiwi-bindings, metadata-builders and merkleize-metadata
held only dist/ builds, and no repository held their source. Every
source map in dist/ embeds the TypeScript it was compiled from; that is
now committed as src/ (59 files), and it matches upstream polkadot-api
(MIT) exactly once @polkadot-api/* imports are renamed:

  papi-utils           @polkadot-api/utils 0.2.0
  bizinikiwi-bindings  @polkadot-api/substrate-bindings 0.16.6
  metadata-builders    @polkadot-api/metadata-builders 0.13.0-0.13.2
  merkleize-metadata   @polkadot-api/merkleize-metadata 1.1.21-1.1.23

scripts/check-papi-sources.mjs, run in the lint job, fails unless the
source embedded in dist/ is exactly the committed src/. tsconfig.json
excludes these src/ trees; ESLint already skipped the packages. Each
README now states the upstream package and version.

* chore(papi): keep the upstream sources in upstream-src/

The pezkuwi-dev build treats any package with a src/ directory as its
own: it requires our license header on every file and builds it. These
are upstream files that must stay byte-identical to the source embedded
in dist/, so they live in upstream-src/ instead, which neither the build
nor the root tsconfig picks up.

packages/papi-utils/upstream-src/AbortError.ts

@@ -0,0 +1,6 @@
+export class AbortError extends Error {
+  constructor() {
+    super("Abort Error")
+    this.name = "AbortError"
+  }
+}

packages/papi-utils/upstream-src/filterObject.ts

@@ -0,0 +1,8 @@
+export function filterObject<K extends string | number | symbol, I>(
+  input: Record<K, I>,
+  filterFn: (i: I, k: K) => boolean,
+): Record<K, I> {
+  return Object.fromEntries(
+    Object.entries(input).filter(([key, value]: any) => filterFn(value, key)),
+  ) as any
+}

packages/papi-utils/upstream-src/hex.ts

@@ -0,0 +1,57 @@
+// https://jsben.ch/uWZw3
+const HEX_STR = "0123456789abcdef"
+export function toHex(bytes: Uint8Array): string {
+  const result = new Array<string>(bytes.length + 1)
+
+  result[0] = "0x"
+
+  for (let i = 0; i < bytes.length; ) {
+    const b = bytes[i++]
+    result[i] = HEX_STR[b >> 4] + HEX_STR[b & 15]
+  }
+
+  return result.join("")
+}
+
+// https://jsben.ch/URe1X
+const HEX_MAP: Record<string, number> = {
+  0: 0,
+  1: 1,
+  2: 2,
+  3: 3,
+  4: 4,
+  5: 5,
+  6: 6,
+  7: 7,
+  8: 8,
+  9: 9,
+  a: 10,
+  b: 11,
+  c: 12,
+  d: 13,
+  e: 14,
+  f: 15,
+  A: 10,
+  B: 11,
+  C: 12,
+  D: 13,
+  E: 14,
+  F: 15,
+}
+export function fromHex(hexString: string): Uint8Array {
+  const isOdd = hexString.length % 2
+  const base = (hexString[1] === "x" ? 2 : 0) + isOdd
+  const nBytes = (hexString.length - base) / 2 + isOdd
+  const bytes = new Uint8Array(nBytes)
+
+  if (isOdd) bytes[0] = 0 | HEX_MAP[hexString[2]]
+
+  for (let i = 0; i < nBytes; ) {
+    const idx = base + i * 2
+    const a = HEX_MAP[hexString[idx]]
+    const b = HEX_MAP[hexString[idx + 1]]
+    bytes[isOdd + i++] = (a << 4) | b
+  }
+
+  return bytes
+}

packages/papi-utils/upstream-src/jsonPrint.ts

@@ -0,0 +1,11 @@
+export const jsonPrint = (value: any, indent = 2) =>
+  JSON.stringify(
+    value,
+    (_, v) =>
+      typeof v === "bigint"
+        ? `${v}n`
+        : typeof v === "object" && typeof v?.asHex === "function"
+          ? v.asHex()
+          : v,
+    indent,
+  )

packages/papi-utils/upstream-src/mapObject.ts

@@ -0,0 +1,29 @@
+export function mapObject<K extends string | number | symbol, I, O>(
+  input: Record<K, I>,
+  mapper: (i: I, k: K) => O,
+): Record<K, O>
+
+export function mapObject<K extends string | number | symbol, I, O>(
+  input: Record<K, I>,
+  mapper: (i: I, k?: K) => O,
+): Record<K, O> {
+  return Object.fromEntries(
+    Object.entries(input).map(
+      ([key, value]: any) => [key, mapper(value, key)] as const,
+    ),
+  ) as any
+}
+
+export type StringRecord<T> = {
+  [Sym: symbol]: never
+  [Num: number]: never
+  [Str: string]: T
+}
+
+export const mapStringRecord = <I, O>(
+  input: StringRecord<I>,
+  mapper: (value: I, key: string) => O,
+): StringRecord<O> =>
+  Object.fromEntries(
+    Object.entries(input).map(([key, value]) => [key, mapper(value, key)]),
+  ) as StringRecord<O>

packages/papi-utils/upstream-src/mergeUint8.ts

@@ -0,0 +1,25 @@
+// TODO: deprecate spread overload in papi v2
+
+interface MergeUint8 {
+  /**
+   * @deprecated This overload will be removed in PAPI v2. Migrate as
+   *             follows:
+   *             mergeUint8(arr1, arr2) => mergeUint8([arr1, arr2])
+   */
+  (...inputs: Array<Uint8Array>): Uint8Array
+  (inputs: Array<Uint8Array>): Uint8Array
+}
+
+export const mergeUint8: MergeUint8 = (...i) => {
+  const inputs = (Array.isArray(i[0]) ? i[0] : i) as Uint8Array[]
+  const totalLen = inputs.reduce((acc, a) => acc + a.byteLength, 0)
+  const result = new Uint8Array(totalLen)
+
+  for (let idx = 0, at = 0; idx < inputs.length; idx++) {
+    const current = inputs[idx]
+    result.set(current, at)
+    at += current.byteLength
+  }
+
+  return result
+}

packages/papi-utils/upstream-src/noop.ts

@@ -0,0 +1 @@
+export const noop: () => void = Function.prototype as any