@ternent/core 0.0.1

package/packages/utils/src/index.ts

@@ -0,0 +1,289 @@
+type BufferLike = {
+  from: (
+    value: Uint8Array | string,
+    encoding?: string,
+  ) => {
+    toString: (encoding: string) => string;
+  };
+};
+
+function getBufferCtor(): BufferLike | null {
+  const maybeBuffer = (globalThis as { Buffer?: BufferLike }).Buffer;
+  return maybeBuffer ?? null;
+}
+
+/**
+ * addNewLines function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function addNewLines(str: string): string {
+  let finalString = "";
+  while (str.length > 0) {
+    finalString += str.substring(0, 64) + "\n";
+    str = str.substring(64);
+  }
+
+  return finalString;
+}
+
+/**
+ * removeLines function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function removeLines(str: string): string {
+  return str.replaceAll("\n", "");
+}
+
+/**
+ * stripIdentityKey function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function stripIdentityKey(key: string) {
+  return key.replace("-----BEGIN PUBLIC KEY-----\n", "").replace("\n-----END PUBLIC KEY-----", "");
+}
+
+/**
+ * formatIdentityKey function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function formatIdentityKey(key: string) {
+  return `-----BEGIN PUBLIC KEY-----\n${key}\n-----END PUBLIC KEY-----`;
+}
+
+/**
+ * stripEncryptionFile function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function stripEncryptionFile(file: string) {
+  return file
+    .replace("-----BEGIN AGE ENCRYPTED FILE-----\n", "")
+    .replace("\n-----END AGE ENCRYPTED FILE-----\n", "");
+}
+
+/**
+ * formatEncryptionFile function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function formatEncryptionFile(file: string) {
+  return `-----BEGIN AGE ENCRYPTED FILE-----\n${file}\n-----END AGE ENCRYPTED FILE-----\n`;
+}
+
+/**
+ * generateId function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function generateId() {
+  const uint32 = crypto.getRandomValues(new Uint32Array(1))[0];
+  return uint32.toString(16);
+}
+
+/**
+ * arrayBufferToBase64 function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function arrayBufferToBase64(arrayBuffer: ArrayBuffer): string {
+  const byteArray = new Uint8Array(arrayBuffer);
+  const bufferCtor = getBufferCtor();
+  if (bufferCtor) {
+    return bufferCtor.from(byteArray).toString("base64");
+  }
+  let byteString = "";
+  for (let i = 0; i < byteArray.byteLength; i++) {
+    byteString += String.fromCharCode(byteArray[i]);
+  }
+  return btoa(byteString);
+}
+
+/**
+ * base64ToArrayBuffer function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function base64ToArrayBuffer(b64: string): ArrayBuffer {
+  const bufferCtor = getBufferCtor();
+  if (bufferCtor) {
+    const bytes = Uint8Array.from(bufferCtor.from(b64, "base64").toString("binary"), (char) =>
+      char.charCodeAt(0),
+    );
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  }
+  const byteString = atob(b64);
+  const byteArray = new Uint8Array(byteString.length);
+  for (let i = 0; i < byteString.length; i++) {
+    byteArray[i] = byteString.charCodeAt(i);
+  }
+
+  return byteArray.buffer;
+}
+
+/**
+ * b64encode function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function b64encode(buf: ArrayBuffer): string {
+  return arrayBufferToBase64(buf);
+}
+
+/**
+ * b64decode function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function b64decode(str: string): ArrayBuffer {
+  return base64ToArrayBuffer(str);
+}
+
+// Encode JSON object to UTF-8 Buffer
+/**
+ * encode function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function encode(data: string | object | number): Uint8Array {
+  const payload = typeof data === "string" ? data : JSON.stringify(data);
+  return new TextEncoder().encode(payload);
+}
+
+/**
+ * decode function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function decode(data: Uint8Array): string {
+  return new TextDecoder("utf-8").decode(new Uint8Array(data));
+}
+
+function toCryptoBuffer(data: Uint8Array | ArrayBuffer): ArrayBuffer {
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  return Uint8Array.from(bytes).buffer;
+}
+
+/**
+ * getHashBuffer function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function getHashBuffer(data: string | object | number): Promise<ArrayBuffer> {
+  return crypto.subtle.digest("SHA-256", toCryptoBuffer(encode(data)));
+}
+
+/**
+ * getHashArray function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function getHashArray(hash: ArrayBuffer): Array<number> {
+  return Array.from(new Uint8Array(hash));
+}
+
+/**
+ * getHashHex function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function getHashHex(hash: Array<number>): string {
+  return hash.map((buf) => buf.toString(16).padStart(2, "0")).join("");
+}
+
+function canonicalize(
+  value: unknown,
+  seen: WeakSet<object>,
+): string | number | boolean | null | Array<unknown> | Record<string, unknown> {
+  if (value === undefined) {
+    throw new TypeError("Cannot hash undefined");
+  }
+  const valueType = typeof value;
+  if (valueType === "function" || valueType === "symbol") {
+    throw new TypeError(`Cannot hash ${valueType} values`);
+  }
+  if (
+    value === null ||
+    valueType === "string" ||
+    valueType === "number" ||
+    valueType === "boolean"
+  ) {
+    return value as string | number | boolean | null;
+  }
+  if (valueType === "bigint") {
+    throw new TypeError("Cannot hash bigint values");
+  }
+
+  if (typeof (value as { toJSON?: () => unknown }).toJSON === "function") {
+    return canonicalize((value as { toJSON: () => unknown }).toJSON(), seen);
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => canonicalize(item, seen));
+  }
+
+  if (typeof value === "object") {
+    if (seen.has(value as object)) {
+      throw new TypeError("Cannot hash circular references");
+    }
+    seen.add(value as object);
+    const entries = Object.keys(value as Record<string, unknown>).sort();
+    const result: Record<string, unknown> = {};
+    for (const key of entries) {
+      result[key] = canonicalize((value as Record<string, unknown>)[key], seen);
+    }
+    seen.delete(value as object);
+    return result;
+  }
+
+  throw new TypeError(`Cannot hash unsupported value type: ${valueType}`);
+}
+
+export function canonicalStringify(data: string | object | number): string {
+  return JSON.stringify(canonicalize(data, new WeakSet()));
+}
+
+export async function hashData(data: string | object | number): Promise<string> {
+  const hash_buffer = await getHashBuffer(canonicalStringify(data));
+  const hash_array = getHashArray(hash_buffer);
+  return getHashHex(hash_array);
+}
+
+export async function hashBytes(input: Uint8Array | ArrayBuffer): Promise<string> {
+  const hashBuffer = await crypto.subtle.digest("SHA-256", toCryptoBuffer(input));
+  return getHashHex(getHashArray(hashBuffer));
+}
+
+// utils/gradientUtils.js
+/**
+ * generateColorStops function - TODO: Add description
+ * @param TODO - Add parameters
+ * @returns TODO - Add return type description
+ */
+export function generateColorStops(primaryColor: string, secondaryColor: string, steps: number) {
+  const colors = [];
+  for (let i = 0; i <= steps; i++) {
+    const ratio = i / steps;
+    const color = lerpColor(primaryColor, secondaryColor, ratio);
+    colors.push(color);
+  }
+  return colors;
+}
+
+function lerpColor(color1: string, color2: string, ratio: number) {
+  const r1 = parseInt(color1.substring(1, 3), 16);
+  const g1 = parseInt(color1.substring(3, 5), 16);
+  const b1 = parseInt(color1.substring(5, 7), 16);
+  const r2 = parseInt(color2.substring(1, 3), 16);
+  const g2 = parseInt(color2.substring(3, 5), 16);
+  const b2 = parseInt(color2.substring(5, 7), 16);
+
+  const r = Math.round(r1 + (r2 - r1) * ratio);
+  const g = Math.round(g1 + (g2 - g1) * ratio);
+  const b = Math.round(b1 + (b2 - b1) * ratio);
+
+  return `#${((1 << 24) | (r << 16) | (g << 8) | b).toString(16).slice(1).toUpperCase()}`;
+}

package/packages/utils/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.test.*", "dist", "node_modules"]
+}

package/packages/utils/vite.config.js

@@ -0,0 +1,28 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+
+const configDir = dirname(fileURLToPath(import.meta.url));
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  output: {
+    exports: "named",
+  },
+  build: {
+    outDir: "dist",
+    minify: false,
+    lib: {
+      entry: resolve(configDir, "src/index.ts"),
+      name: "ternent-utils",
+      fileName: "utils",
+      formats: ["es"],
+    },
+    rollupOptions: {
+      output: {
+        format: "es",
+        entryFileNames: "utils.es.js",
+      },
+    },
+  },
+});

package/pnpm-workspace.yaml

@@ -0,0 +1,8 @@
+packages:
+  - "packages/armour"
+  # - "packages/concord"
+  - "packages/identity"
+  # - "packages/ledger"
+  - "packages/seal"
+  - "packages/ui"
+  - "packages/utils"

package/scripts/vite/package-lib-config.ts

@@ -0,0 +1,59 @@
+import { builtinModules } from "node:module";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+type PackageJsonShape = {
+  dependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
+};
+
+function loadPackageJson(packageDir: string): PackageJsonShape {
+  const packageJsonPath = resolve(packageDir, "package.json");
+  return JSON.parse(readFileSync(packageJsonPath, "utf8")) as PackageJsonShape;
+}
+
+function createPackageNames(packageJson: PackageJsonShape) {
+  return new Set([
+    ...Object.keys(packageJson.dependencies || {}),
+    ...Object.keys(packageJson.peerDependencies || {}),
+    ...Object.keys(packageJson.optionalDependencies || {}),
+  ]);
+}
+
+function isExternalId(id: string, packageNames: Set<string>, includeNodeBuiltins: boolean) {
+  if (includeNodeBuiltins) {
+    if (builtinModules.includes(id) || builtinModules.includes(id.replace(/^node:/, ""))) {
+      return true;
+    }
+    if (id.startsWith("node:")) {
+      return true;
+    }
+  }
+
+  for (const packageName of packageNames) {
+    if (id === packageName || id.startsWith(`${packageName}/`)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function createPackageExternal(
+  packageDir: string,
+  options: { includeNodeBuiltins?: boolean } = {},
+) {
+  const packageJson = loadPackageJson(packageDir);
+  const packageNames = createPackageNames(packageJson);
+  const includeNodeBuiltins = options.includeNodeBuiltins === true;
+
+  return function external(id: string) {
+    return isExternalId(id, packageNames, includeNodeBuiltins);
+  };
+}
+
+export function resolvePackageDir(metaUrl: string) {
+  return dirname(fileURLToPath(metaUrl));
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "strict": true,
+    "jsx": "preserve",
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "lib": ["ESNext", "DOM"],
+    "skipLibCheck": true,
+    "allowJs": true,
+    "declaration": true,
+    "declarationMap": true,
+    "paths": {
+      "@/*": ["./src"]
+    }
+  },
+  "include": ["**/*.ts", "**/*.d.ts", "**/*.tsx", "**/*.vue"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

package/tsconfig.node.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["apps/footballsocial/vite.config.ts", "packages/identity/vite.config.ts"]
+}