vibe64 0.1.21

package/node_modules/@jskit-ai/kernel/shared/support/normalize.js

@@ -0,0 +1,379 @@
+function normalizeText(value, { fallback = "" } = {}) {
+  const normalized = String(value || "").trim();
+  return normalized || fallback;
+}
+
+function hasValue(value) {
+  if (value == null) {
+    return false;
+  }
+
+  if (typeof value === "string") {
+    return normalizeText(value).length > 0;
+  }
+
+  return true;
+}
+
+function normalizeBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+
+  if (typeof value === "number") {
+    if (value === 1) {
+      return true;
+    }
+    if (value === 0) {
+      return false;
+    }
+  }
+
+  const normalized = normalizeText(value).toLowerCase();
+  if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "y") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "n") {
+    return false;
+  }
+
+  throw new TypeError("Boolean field must be true or false.");
+}
+
+function normalizeFiniteNumber(value) {
+  const normalized = Number(value);
+  if (!Number.isFinite(normalized)) {
+    throw new TypeError("Number field must be a valid number.");
+  }
+  return normalized;
+}
+
+function normalizeFiniteInteger(value) {
+  const normalized = normalizeFiniteNumber(value);
+  if (!Number.isInteger(normalized)) {
+    throw new TypeError("Number field must be an integer.");
+  }
+  return normalized;
+}
+
+function normalizeLowerText(value, { fallback = "" } = {}) {
+  return normalizeText(value, {
+    fallback
+  }).toLowerCase();
+}
+
+function normalizeQueryToken(value, { fallback = "__none__" } = {}) {
+  const normalized = normalizeText(value).toLowerCase();
+  return normalized || fallback;
+}
+
+function normalizeObject(value, { fallback = {} } = {}) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return { ...fallback };
+  }
+  return value;
+}
+
+function normalizeIfInSource(source, normalized, fieldName, normalizer = (value) => value) {
+  if (!isRecord(source)) {
+    return normalized;
+  }
+  if (!isRecord(normalized)) {
+    throw new TypeError("normalizeIfInSource requires target object.");
+  }
+
+  const normalizedFieldName = normalizeText(fieldName);
+  if (!normalizedFieldName) {
+    throw new TypeError("normalizeIfInSource requires fieldName.");
+  }
+  if (typeof normalizer !== "function") {
+    throw new TypeError("normalizeIfInSource requires normalizer function.");
+  }
+
+  if (!Object.hasOwn(source, normalizedFieldName)) {
+    return normalized;
+  }
+
+  const sourceValue = source[normalizedFieldName];
+  if (sourceValue == null) {
+    normalized[normalizedFieldName] = sourceValue;
+    return normalized;
+  }
+
+  try {
+    normalized[normalizedFieldName] = normalizer(sourceValue);
+  } catch (error) {
+    const normalizedMessage = normalizeText(error?.message, {
+      fallback: `${normalizedFieldName} is invalid.`
+    });
+    const sourceDetails = isRecord(error?.details) ? error.details : {};
+    const sourceFieldErrors = isRecord(error?.fieldErrors)
+      ? { ...error.fieldErrors }
+      : isRecord(sourceDetails.fieldErrors)
+        ? { ...sourceDetails.fieldErrors }
+        : {};
+
+    if (!normalizeText(sourceFieldErrors[normalizedFieldName])) {
+      sourceFieldErrors[normalizedFieldName] = normalizedMessage;
+    }
+
+    const normalizedError = error instanceof Error ? error : new Error(normalizedMessage);
+    normalizedError.fieldErrors = sourceFieldErrors;
+    normalizedError.details = {
+      ...sourceDetails,
+      fieldErrors: sourceFieldErrors
+    };
+    throw normalizedError;
+  }
+  return normalized;
+}
+
+function normalizeIfPresent(value, normalizer = (entry) => entry) {
+  if (typeof normalizer !== "function") {
+    throw new TypeError("normalizeIfPresent requires normalizer function.");
+  }
+  return value == null ? value : normalizer(value);
+}
+
+function normalizeOrNull(value, normalizer = (entry) => entry) {
+  if (typeof normalizer !== "function") {
+    throw new TypeError("normalizeOrNull requires normalizer function.");
+  }
+  return value == null ? null : normalizer(value);
+}
+
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+function normalizeArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function normalizeUniqueTextList(value, { acceptSingle = false } = {}) {
+  const source = Array.isArray(value) ? value : acceptSingle ? [value] : [];
+  return Array.from(new Set(source.map((entry) => normalizeText(entry)).filter(Boolean)));
+}
+
+function normalizeInteger(value, { fallback = 0, min = null, max = null } = {}) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) {
+    return fallback;
+  }
+
+  let next = Math.trunc(numeric);
+  if (Number.isFinite(min) && next < min) {
+    next = min;
+  }
+  if (Number.isFinite(max) && next > max) {
+    next = max;
+  }
+  return next;
+}
+
+function normalizePositiveInteger(value, { fallback = 0 } = {}) {
+  const numeric = Number(value);
+  if (!Number.isInteger(numeric) || numeric < 1) {
+    return fallback;
+  }
+
+  return numeric;
+}
+
+function normalizeCanonicalRecordIdText(value, { fallback = null } = {}) {
+  if (value == null) {
+    return fallback;
+  }
+
+  const normalized = String(value).trim();
+  return /^[1-9][0-9]*$/.test(normalized) ? normalized : fallback;
+}
+
+function normalizeRecordId(value, { fallback = null } = {}) {
+  if (value == null) {
+    return fallback;
+  }
+
+  if (typeof value === "string") {
+    return normalizeCanonicalRecordIdText(value, { fallback });
+  }
+
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value < 1) {
+      return fallback;
+    }
+    return normalizeCanonicalRecordIdText(value, { fallback });
+  }
+
+  if (typeof value === "bigint") {
+    if (value < 1n) {
+      return fallback;
+    }
+    return normalizeCanonicalRecordIdText(value, { fallback });
+  }
+
+  return fallback;
+}
+
+function normalizeOpaqueId(value, { fallback = null } = {}) {
+  if (value == null) {
+    return fallback;
+  }
+
+  if (typeof value === "string") {
+    const normalized = value.trim();
+    return normalized || fallback;
+  }
+
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? String(value) : fallback;
+  }
+
+  if (typeof value === "bigint") {
+    return String(value);
+  }
+
+  return fallback;
+}
+
+function normalizeOneOf(value, allowedValues = [], fallback = "") {
+  const normalized = normalizeText(value).toLowerCase();
+  const supported = Array.isArray(allowedValues)
+    ? allowedValues.map((entry) => normalizeText(entry).toLowerCase()).filter(Boolean)
+    : [];
+
+  if (supported.includes(normalized)) {
+    return normalized;
+  }
+
+  const normalizedFallback = normalizeText(fallback).toLowerCase();
+  if (normalizedFallback) {
+    return normalizedFallback;
+  }
+
+  return supported[0] || "";
+}
+
+const MOBILE_ASSET_MODES = Object.freeze(["bundled", "dev_server"]);
+const MOBILE_STRATEGIES = Object.freeze(["capacitor"]);
+const DEFAULT_MOBILE_AUTH_CONFIG = Object.freeze({
+  callbackPath: "/auth/login",
+  customScheme: "",
+  appLinkDomains: Object.freeze([])
+});
+const DEFAULT_MOBILE_ANDROID_CONFIG = Object.freeze({
+  packageName: "",
+  minSdk: 26,
+  targetSdk: 35,
+  versionCode: 1,
+  versionName: "1.0.0"
+});
+
+function normalizeMobileStrategy(value = "", { fallback = "" } = {}) {
+  const normalized = normalizeLowerText(value);
+  return MOBILE_STRATEGIES.includes(normalized) ? normalized : normalizeLowerText(fallback);
+}
+
+function normalizeMobileAssetMode(value = "", { fallback = "bundled" } = {}) {
+  const normalized = normalizeLowerText(value);
+  if (!normalized) {
+    return normalizeLowerText(fallback, {
+      fallback: "bundled"
+    });
+  }
+  if (!MOBILE_ASSET_MODES.includes(normalized)) {
+    throw new TypeError('config.mobile.assetMode must be "bundled" or "dev_server".');
+  }
+  return normalized;
+}
+
+function normalizeMobileCallbackPath(value = "", { fallback = "/auth/login" } = {}) {
+  const normalized = normalizeText(value, {
+    fallback
+  });
+  if (!normalized) {
+    return "";
+  }
+
+  return normalized.startsWith("/") ? normalized : `/${normalized}`;
+}
+
+function normalizeMobileConfig(source = {}) {
+  const mobile = normalizeObject(source);
+  const auth = normalizeObject(mobile.auth);
+  const android = normalizeObject(mobile.android);
+
+  return Object.freeze({
+    enabled: hasValue(mobile.enabled) ? normalizeBoolean(mobile.enabled) : false,
+    strategy: normalizeMobileStrategy(mobile.strategy),
+    appId: normalizeText(mobile.appId),
+    appName: normalizeText(mobile.appName),
+    assetMode: normalizeMobileAssetMode(mobile.assetMode),
+    devServerUrl: normalizeText(mobile.devServerUrl),
+    apiBaseUrl: normalizeText(mobile.apiBaseUrl),
+    auth: Object.freeze({
+      callbackPath: normalizeMobileCallbackPath(auth.callbackPath, {
+        fallback: DEFAULT_MOBILE_AUTH_CONFIG.callbackPath
+      }),
+      customScheme: normalizeLowerText(auth.customScheme),
+      appLinkDomains: Object.freeze([
+        ...new Set(
+          normalizeUniqueTextList(auth.appLinkDomains, {
+            acceptSingle: true
+          }).map((entry) => normalizeLowerText(entry))
+        )
+      ])
+    }),
+    android: Object.freeze({
+      packageName: normalizeText(android.packageName),
+      minSdk: normalizePositiveInteger(android.minSdk, {
+        fallback: DEFAULT_MOBILE_ANDROID_CONFIG.minSdk
+      }),
+      targetSdk: normalizePositiveInteger(android.targetSdk, {
+        fallback: DEFAULT_MOBILE_ANDROID_CONFIG.targetSdk
+      }),
+      versionCode: normalizePositiveInteger(android.versionCode, {
+        fallback: DEFAULT_MOBILE_ANDROID_CONFIG.versionCode
+      }),
+      versionName: normalizeText(android.versionName, {
+        fallback: DEFAULT_MOBILE_ANDROID_CONFIG.versionName
+      })
+    })
+  });
+}
+
+function ensureNonEmptyText(value, label = "value") {
+  const normalized = normalizeText(value);
+  if (!normalized) {
+    throw new TypeError(`${label} is required.`);
+  }
+  return normalized;
+}
+
+export {
+  normalizeText,
+  hasValue,
+  normalizeBoolean,
+  normalizeFiniteNumber,
+  normalizeFiniteInteger,
+  normalizeLowerText,
+  normalizeQueryToken,
+  normalizeObject,
+  normalizeIfInSource,
+  normalizeIfPresent,
+  normalizeOrNull,
+  isRecord,
+  normalizeArray,
+  normalizeUniqueTextList,
+  normalizeInteger,
+  normalizePositiveInteger,
+  normalizeCanonicalRecordIdText,
+  normalizeRecordId,
+  normalizeOpaqueId,
+  normalizeOneOf,
+  normalizeMobileAssetMode,
+  normalizeMobileCallbackPath,
+  normalizeMobileConfig,
+  normalizeMobileStrategy,
+  ensureNonEmptyText
+};

package/node_modules/@jskit-ai/kernel/shared/support/normalize.test.js

@@ -0,0 +1,326 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  hasValue,
+  normalizeBoolean,
+  normalizeCanonicalRecordIdText,
+  normalizeFiniteInteger,
+  normalizeFiniteNumber,
+  normalizeIfInSource,
+  normalizeIfPresent,
+  normalizeMobileCallbackPath,
+  normalizeMobileConfig,
+  normalizeOrNull,
+  normalizeRecordId,
+  normalizeOpaqueId,
+  normalizePositiveInteger,
+  normalizeOneOf,
+  normalizeQueryToken,
+  normalizeText,
+  normalizeUniqueTextList
+} from "./normalize.js";
+
+test("hasValue returns false for nullish and blank text, true otherwise", () => {
+  assert.equal(hasValue(null), false);
+  assert.equal(hasValue(undefined), false);
+  assert.equal(hasValue(""), false);
+  assert.equal(hasValue("   "), false);
+  assert.equal(hasValue("0"), true);
+  assert.equal(hasValue("-"), true);
+  assert.equal(hasValue(0), true);
+  assert.equal(hasValue(false), true);
+  assert.equal(hasValue([]), true);
+  assert.equal(hasValue({}), true);
+});
+
+test("normalizeQueryToken trims, lowercases, and falls back when empty", () => {
+  assert.equal(normalizeQueryToken("  Admin  "), "admin");
+  assert.equal(normalizeQueryToken(""), "__none__");
+  assert.equal(normalizeQueryToken(null), "__none__");
+  assert.equal(normalizeQueryToken("   ", { fallback: "surface" }), "surface");
+});
+
+test("normalizeOneOf returns normalized value when supported", () => {
+  assert.equal(normalizeOneOf(" Compact ", ["compact", "comfortable"], "comfortable"), "compact");
+});
+
+test("normalizeOneOf returns fallback when value is unsupported", () => {
+  assert.equal(normalizeOneOf("wide", ["compact", "comfortable"], "comfortable"), "comfortable");
+});
+
+test("normalizeOneOf falls back to first allowed value when fallback is empty", () => {
+  assert.equal(normalizeOneOf("", ["compact", "comfortable"], ""), "compact");
+});
+
+test("normalizePositiveInteger normalizes valid integers and applies fallback", () => {
+  assert.equal(normalizePositiveInteger("12"), 12);
+  assert.equal(normalizePositiveInteger(0), 0);
+  assert.equal(normalizePositiveInteger(-1), 0);
+  assert.equal(
+    normalizePositiveInteger("abc", {
+      fallback: null
+    }),
+    null
+  );
+});
+
+test("normalizeBoolean normalizes supported boolean-like values", () => {
+  assert.equal(normalizeBoolean(true), true);
+  assert.equal(normalizeBoolean(false), false);
+  assert.equal(normalizeBoolean(1), true);
+  assert.equal(normalizeBoolean(0), false);
+  assert.equal(normalizeBoolean(" yes "), true);
+  assert.equal(normalizeBoolean("No"), false);
+  assert.throws(() => normalizeBoolean("maybe"), /Boolean field must be true or false/);
+});
+
+test("normalizeFiniteNumber normalizes numeric values", () => {
+  assert.equal(normalizeFiniteNumber("42.5"), 42.5);
+  assert.equal(normalizeFiniteNumber("7"), 7);
+  assert.throws(() => normalizeFiniteNumber("abc"), /Number field must be a valid number/);
+});
+
+test("normalizeFiniteInteger normalizes integer values", () => {
+  assert.equal(normalizeFiniteInteger("7"), 7);
+  assert.throws(
+    () => normalizeFiniteInteger("3.2"),
+    /Number field must be an integer/
+  );
+});
+
+test("normalizeIfInSource normalizes only present source fields", () => {
+  const source = {
+    firstName: "  Ada  "
+  };
+  const normalized = {};
+
+  normalizeIfInSource(source, normalized, "firstName", normalizeText);
+  normalizeIfInSource(source, normalized, "lastName", normalizeText);
+
+  assert.deepEqual(normalized, {
+    firstName: "Ada"
+  });
+});
+
+test("normalizeIfInSource passes through nullish values without normalizer", () => {
+  const source = {
+    firstName: null,
+    lastName: undefined
+  };
+  const normalized = {};
+
+  normalizeIfInSource(source, normalized, "firstName", normalizeText);
+  normalizeIfInSource(source, normalized, "lastName", normalizeText);
+
+  assert.deepEqual(normalized, {
+    firstName: null,
+    lastName: undefined
+  });
+});
+
+test("normalizeIfInSource annotates thrown normalizer errors with fieldErrors", () => {
+  const source = {
+    temperament: "unknowne"
+  };
+  const normalized = {};
+
+  assert.throws(
+    () =>
+      normalizeIfInSource(source, normalized, "temperament", () => {
+        throw new Error("Invalid pet temperament \"unknowne\".");
+      }),
+    (error) => {
+      assert.deepEqual(error?.fieldErrors, {
+        temperament: "Invalid pet temperament \"unknowne\"."
+      });
+      assert.deepEqual(error?.details?.fieldErrors, {
+        temperament: "Invalid pet temperament \"unknowne\"."
+      });
+      return true;
+    }
+  );
+});
+
+test("normalizeIfInSource validates target and function arguments", () => {
+  assert.throws(
+    () => normalizeIfInSource({ firstName: "Ada" }, null, "firstName", normalizeText),
+    /requires target object/
+  );
+  assert.throws(
+    () => normalizeIfInSource({ firstName: "Ada" }, {}, "", normalizeText),
+    /requires fieldName/
+  );
+  assert.throws(
+    () => normalizeIfInSource({ firstName: "Ada" }, {}, "firstName", null),
+    /requires normalizer function/
+  );
+});
+
+test("normalizeIfPresent normalizes non-nullish values and preserves nullish values", () => {
+  assert.equal(normalizeIfPresent("  Ada  ", normalizeText), "Ada");
+  assert.equal(normalizeIfPresent(null, normalizeText), null);
+  assert.equal(normalizeIfPresent(undefined, normalizeText), undefined);
+  assert.throws(
+    () => normalizeIfPresent("Ada", null),
+    /requires normalizer function/
+  );
+});
+
+test("normalizeOrNull normalizes non-nullish values and coerces nullish to null", () => {
+  assert.equal(normalizeOrNull("  Ada  ", normalizeText), "Ada");
+  assert.equal(normalizeOrNull(null, normalizeText), null);
+  assert.equal(normalizeOrNull(undefined, normalizeText), null);
+  assert.throws(
+    () => normalizeOrNull("Ada", null),
+    /requires normalizer function/
+  );
+});
+
+test("normalizeRecordId accepts canonical string, safe integer, and bigint identifiers", () => {
+  const unsafeNumericId = Number(9007199254740993n);
+  assert.equal(normalizeRecordId("  7  "), "7");
+  assert.equal(normalizeRecordId(7), "7");
+  assert.equal(normalizeRecordId(10n), "10");
+  assert.equal(normalizeRecordId(7.5), null);
+  assert.equal(normalizeRecordId(0), null);
+  assert.equal(normalizeRecordId(unsafeNumericId), null);
+  assert.equal(normalizeRecordId(""), null);
+  assert.equal(normalizeRecordId(null), null);
+});
+
+test("normalizeCanonicalRecordIdText validates canonical positive decimal identifiers", () => {
+  assert.equal(normalizeCanonicalRecordIdText("  7  "), "7");
+  assert.equal(normalizeCanonicalRecordIdText("007"), null);
+  assert.equal(normalizeCanonicalRecordIdText("0"), null);
+  assert.equal(normalizeCanonicalRecordIdText("abc"), null);
+});
+
+test("normalizeOpaqueId preserves opaque identifiers", () => {
+  assert.equal(normalizeOpaqueId("  user-123  "), "user-123");
+  assert.equal(normalizeOpaqueId(7), "7");
+  assert.equal(normalizeOpaqueId(0), "0");
+  assert.equal(normalizeOpaqueId(10n), "10");
+  assert.equal(normalizeOpaqueId(""), null);
+  assert.equal(normalizeOpaqueId(null), null);
+});
+
+test("normalizeUniqueTextList trims, dedupes, and supports optional single values", () => {
+  assert.deepEqual(normalizeUniqueTextList([" one ", "two", "one", "", null]), ["one", "two"]);
+  assert.deepEqual(normalizeUniqueTextList("one"), []);
+  assert.deepEqual(
+    normalizeUniqueTextList(" one ", {
+      acceptSingle: true
+    }),
+    ["one"]
+  );
+});
+
+test("normalizeMobileCallbackPath normalizes auth callback paths", () => {
+  assert.equal(normalizeMobileCallbackPath("auth/login"), "/auth/login");
+  assert.equal(normalizeMobileCallbackPath("/auth/login"), "/auth/login");
+  assert.equal(
+    normalizeMobileCallbackPath("", {
+      fallback: "/login/callback"
+    }),
+    "/login/callback"
+  );
+});
+
+test("normalizeMobileConfig normalizes the mobile config contract", () => {
+  const mobileConfig = normalizeMobileConfig({
+    enabled: true,
+    strategy: " Capacitor ",
+    appId: "com.example.convict",
+    appName: "Convict",
+    assetMode: " dev_server ",
+    devServerUrl: " http://192.168.1.10:5173 ",
+    apiBaseUrl: " https://api.example.com ",
+    auth: {
+      callbackPath: "auth/login",
+      customScheme: " Convict ",
+      appLinkDomains: ["App.Example.com", " app.example.com "]
+    },
+    android: {
+      packageName: "com.example.convict",
+      minSdk: "28",
+      targetSdk: "35",
+      versionCode: "4",
+      versionName: "2.0.0"
+    }
+  });
+
+  assert.deepEqual(mobileConfig, {
+    enabled: true,
+    strategy: "capacitor",
+    appId: "com.example.convict",
+    appName: "Convict",
+    assetMode: "dev_server",
+    devServerUrl: "http://192.168.1.10:5173",
+    apiBaseUrl: "https://api.example.com",
+    auth: {
+      callbackPath: "/auth/login",
+      customScheme: "convict",
+      appLinkDomains: ["app.example.com"]
+    },
+    android: {
+      packageName: "com.example.convict",
+      minSdk: 28,
+      targetSdk: 35,
+      versionCode: 4,
+      versionName: "2.0.0"
+    }
+  });
+});
+
+test("normalizeMobileConfig applies defaults for missing fields", () => {
+  const mobileConfig = normalizeMobileConfig({
+    auth: {
+      appLinkDomains: "app.example.com"
+    },
+    android: {
+      minSdk: "bad",
+      targetSdk: 0,
+      versionCode: "",
+      versionName: ""
+    }
+  });
+
+  assert.deepEqual(mobileConfig, {
+    enabled: false,
+    strategy: "",
+    appId: "",
+    appName: "",
+    assetMode: "bundled",
+    devServerUrl: "",
+    apiBaseUrl: "",
+    auth: {
+      callbackPath: "/auth/login",
+      customScheme: "",
+      appLinkDomains: ["app.example.com"]
+    },
+    android: {
+      packageName: "",
+      minSdk: 26,
+      targetSdk: 35,
+      versionCode: 1,
+      versionName: "1.0.0"
+    }
+  });
+});
+
+test("normalizeMobileConfig preserves explicit false values from string input", () => {
+  const mobileConfig = normalizeMobileConfig({
+    enabled: "false"
+  });
+
+  assert.equal(mobileConfig.enabled, false);
+});
+
+test("normalizeMobileConfig rejects invalid assetMode values", () => {
+  assert.throws(
+    () => normalizeMobileConfig({
+      assetMode: "weird"
+    }),
+    /config\.mobile\.assetMode must be "bundled" or "dev_server"\./u
+  );
+});