@raytio/core 11.4.1 → 11.6.0

package/dist/crypto/pgpKey/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * PGP Key Types
+ *
+ * Types for device-bound PGP keys used for digital signatures.
+ * Issue #1374
+ */
+/**
+ * Supported PGP key algorithms
+ */
+export type PGPKeyAlgorithm = "RSA-4096" | "RSA-2048";
+/**
+ * PGP private key storage record (IndexedDB)
+ */
+export interface StoredPGPPrivateKey {
+    /** AES-GCM encrypted private key bytes */
+    encryptedPrivateKey: Uint8Array;
+    /** 12-byte initialization vector for decryption */
+    iv: Uint8Array;
+    /** User's Cognito sub (user ID) */
+    userId: string;
+    /** SHA-256 fingerprint of the public key (first 40 hex chars) */
+    keyId: string;
+    /** Algorithm identifier for future compatibility */
+    algorithm: PGPKeyAlgorithm;
+    /** When the key was created */
+    createdAt: string;
+    /** Unique identifier for the device that generated/imported the key */
+    deviceId: string;
+}
+/**
+ * PGP public key properties (stored as profile object)
+ */
+export interface PGPPublicKeyProperties {
+    /** Public key in PEM format (SPKI) */
+    publicKey: string;
+    /** SHA-256 fingerprint for matching with private key */
+    keyId: string;
+    /** Algorithm identifier */
+    algorithm: PGPKeyAlgorithm;
+    /** When the key was created */
+    createdAt: string;
+    /** Device that generated/imported the key */
+    deviceId: string;
+}
+/**
+ * Generated key pair (before encryption)
+ */
+export interface PGPKeyPair {
+    /** Public key in PEM format */
+    publicKeyPem: string;
+    /** Private key in PKCS8 format (raw bytes) */
+    privateKeyBytes: Uint8Array;
+    /** Key fingerprint */
+    keyId: string;
+    /** Algorithm */
+    algorithm: PGPKeyAlgorithm;
+}
+/**
+ * PGP key storage interface
+ */
+export interface PGPKeyStorage {
+    /** Store an encrypted private key */
+    store(record: StoredPGPPrivateKey): Promise<void>;
+    /** Retrieve an encrypted private key */
+    get(userId: string): Promise<StoredPGPPrivateKey | null>;
+    /** Delete a private key */
+    delete(userId: string): Promise<void>;
+    /** Check if a private key exists */
+    exists(userId: string): Promise<boolean>;
+}
+/**
+ * IndexedDB configuration for PGP key storage
+ */
+export declare const PGP_KEY_DB_CONFIG: {
+    readonly name: "raytio-pgp-keys";
+    readonly version: 1;
+    readonly storeName: "private-keys";
+};
+/**
+ * AES-GCM IV size in bytes
+ */
+export declare const AES_GCM_IV_SIZE = 12;
+/**
+ * Key fingerprint length (hex characters)
+ */
+export declare const KEY_FINGERPRINT_LENGTH = 40;

package/dist/crypto/pgpKey/types.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * PGP Key Types
+ *
+ * Types for device-bound PGP keys used for digital signatures.
+ * Issue #1374
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEY_FINGERPRINT_LENGTH = exports.AES_GCM_IV_SIZE = exports.PGP_KEY_DB_CONFIG = void 0;
+/**
+ * IndexedDB configuration for PGP key storage
+ */
+exports.PGP_KEY_DB_CONFIG = {
+    name: "raytio-pgp-keys",
+    version: 1,
+    storeName: "private-keys",
+};
+/**
+ * AES-GCM IV size in bytes
+ */
+exports.AES_GCM_IV_SIZE = 12;
+/**
+ * Key fingerprint length (hex characters)
+ */
+exports.KEY_FINGERPRINT_LENGTH = 40;

package/dist/index.d.ts

@@ -3,4 +3,5 @@ export * from "./crypto";
 export * from "./general";
 export * from "./rules";
 export * from "./schema";
+export * from "./util";
 export * from "./verifications";

package/dist/index.js

@@ -19,4 +19,5 @@ __exportStar(require("./crypto"), exports);
 __exportStar(require("./general"), exports);
 __exportStar(require("./rules"), exports);
 __exportStar(require("./schema"), exports);
+__exportStar(require("./util"), exports);
 __exportStar(require("./verifications"), exports);

package/dist/rules/calculateScore.d.ts

@@ -8,7 +8,7 @@ export declare function evaluateRule(rule: ScoreRule, data: RuleData): {
 export type ScoreResult = {
     score: number;
     category: string;
-    categoryColour: string | undefined;
+    categoryColour: string | null | undefined;
     diagnostics: {
         version: string;
         config: {

package/dist/rules/convertInstanceToRuleInput.js

@@ -34,107 +34,109 @@ const convertInstanceToRuleInput = async (POs, realVers, getSchema) => {
         if (schemaName === VERIFICATION_SCHEMA)
             continue;
         const schema = await getSchema(schemaName);
-        const verified = (0, verifications_1.getPOVerification)({ PO, schema, realVers });
-        // remove anything we can't make rules for (e.g. object), and
-        // also remove any fields that aren't defined in the schema.
-        const validFields = Object.entries(PO.properties).filter(([fieldName, value]) => getTypeofFieldValue(value) && schema.properties[fieldName]);
-        const nonDateProperties = validFields
-            .filter(d => !isDateField(schema)(d))
-            .map(([fieldName, value]) => {
-            var _a;
-            const verifiedBy = (0, ramda_1.uniq)((_a = realVers
-                .filter(x => x.belongsToNId === PO.n_id &&
-                x.fieldName === fieldName &&
-                x.provider.verifierNId)) === null || _a === void 0 ? void 0 : _a.map(x => x.provider.verifierNId));
-            const field = {
-                hField: {
-                    __typeof__: helpers_1.HFieldSymbol,
-                    cameFromSchema: schemaName,
-                    verification: verified.fieldVerifications[fieldName],
-                    verifiedBy,
-                },
-                type: getTypeofFieldValue(value),
-                value,
-            };
-            return [fieldName, field];
-        });
-        const dateFieldByCategorys = (0, ramda_1.groupBy)(([fieldName]) => schema.properties[fieldName].tags.find(tag => tag.startsWith("group:date_picker")), validFields.filter(isDateField(schema)));
-        // the three date fields become one pseudo field for the score system
-        const pseudoDateFields = Object.entries(dateFieldByCategorys).map(([groupTag, _members]) => {
-            var _a;
-            // obviously this won't be undefined since we're
-            // looping through the object.
-            const members = _members;
-            const groupName = groupTag.split(":")[2] || "NO_NAME";
-            const memberFieldNames = members.map(x => x[0]);
-            const worstVer = (0, ramda_1.sort)((a, b) => b - a, // find the highest enum value (that's the worst)
-            memberFieldNames.map(f => verified.fieldVerifications[f]))[0];
-            const fieldVers = (0, ramda_1.uniq)((_a = realVers
-                .filter(x => x.belongsToNId === PO.n_id &&
-                memberFieldNames.includes(x.fieldName) &&
-                x.provider.verifierNId)) === null || _a === void 0 ? void 0 : _a.map(v => v.provider.verifierNId).filter((val) => !!val));
-            const values = Object.fromEntries(members);
-            const dayFieldName = memberFieldNames.find(f => { var _a; return (_a = schema.properties[f].tags) === null || _a === void 0 ? void 0 : _a.includes("date_component:day"); });
-            const monthFieldName = memberFieldNames.find(f => { var _a; return (_a = schema.properties[f].tags) === null || _a === void 0 ? void 0 : _a.includes("date_component:month"); });
-            const yearFieldName = memberFieldNames.find(f => { var _a; return (_a = schema.properties[f].tags) === null || _a === void 0 ? void 0 : _a.includes("date_component:year"); });
-            if (!dayFieldName || !monthFieldName || !yearFieldName) {
-                throw new Error("Failed to infer date component field");
-            }
-            const isoString = [
-                values[yearFieldName],
-                `${values[monthFieldName]}`.padStart(2, "0"),
-                `${values[dayFieldName]}`.padStart(2, "0"),
-            ].join("-");
-            const pseudoField = {
-                hField: {
-                    __typeof__: helpers_1.HFieldSymbol,
-                    cameFromSchema: schemaName,
-                    verification: worstVer,
-                    verifiedBy: fieldVers,
-                },
-                type: "Date",
-                value: new Date(isoString),
-            };
-            return [`__group_${groupName}`, pseudoField];
-        });
-        const deepProperties = Object.entries(PO.properties)
-            .filter(([fieldName, fieldValue]) => {
-            const field = schema.properties[fieldName];
-            return (field &&
-                field.type === "object" &&
-                field.properties &&
-                fieldValue &&
-                typeof fieldValue === "object");
-        })
-            .flatMap(([fieldName, fieldValue]) => {
-            const subFields = Object.keys(schema.properties[fieldName].properties);
-            return subFields.map(subFieldName => {
-                const value = fieldValue[subFieldName];
-                const hsubfield = {
-                    hField: null, // you can't access metadata on a subfield
+        if (schema) {
+            const verified = (0, verifications_1.getPOVerification)({ PO, schema, realVers });
+            // remove anything we can't make rules for (e.g. object), and
+            // also remove any fields that aren't defined in the schema.
+            const validFields = Object.entries(PO.properties).filter(([fieldName, value]) => getTypeofFieldValue(value) && schema.properties[fieldName]);
+            const nonDateProperties = validFields
+                .filter(d => !isDateField(schema)(d))
+                .map(([fieldName, value]) => {
+                var _a;
+                const verifiedBy = (0, ramda_1.uniq)((_a = realVers
+                    .filter(x => x.belongsToNId === PO.n_id &&
+                    x.fieldName === fieldName &&
+                    x.provider.verifierNId)) === null || _a === void 0 ? void 0 : _a.map(x => x.provider.verifierNId));
+                const field = {
+                    hField: {
+                        __typeof__: helpers_1.HFieldSymbol,
+                        cameFromSchema: schemaName,
+                        verification: verified.fieldVerifications[fieldName],
+                        verifiedBy,
+                    },
                     type: getTypeofFieldValue(value),
                     value,
                 };
-                return [`${fieldName}|${subFieldName}`, hsubfield];
+                return [fieldName, field];
+            });
+            const dateFieldByCategorys = (0, ramda_1.groupBy)(([fieldName]) => schema.properties[fieldName].tags.find(tag => tag.startsWith("group:date_picker")), validFields.filter(isDateField(schema)));
+            // the three date fields become one pseudo field for the score system
+            const pseudoDateFields = Object.entries(dateFieldByCategorys).map(([groupTag, _members]) => {
+                var _a;
+                // obviously this won't be undefined since we're
+                // looping through the object.
+                const members = _members;
+                const groupName = groupTag.split(":")[2] || "NO_NAME";
+                const memberFieldNames = members.map(x => x[0]);
+                const worstVer = (0, ramda_1.sort)((a, b) => b - a, // find the highest enum value (that's the worst)
+                memberFieldNames.map(f => verified.fieldVerifications[f]))[0];
+                const fieldVers = (0, ramda_1.uniq)((_a = realVers
+                    .filter(x => x.belongsToNId === PO.n_id &&
+                    memberFieldNames.includes(x.fieldName) &&
+                    x.provider.verifierNId)) === null || _a === void 0 ? void 0 : _a.map(v => v.provider.verifierNId).filter((val) => !!val));
+                const values = Object.fromEntries(members);
+                const dayFieldName = memberFieldNames.find(f => { var _a; return (_a = schema.properties[f].tags) === null || _a === void 0 ? void 0 : _a.includes("date_component:day"); });
+                const monthFieldName = memberFieldNames.find(f => { var _a; return (_a = schema.properties[f].tags) === null || _a === void 0 ? void 0 : _a.includes("date_component:month"); });
+                const yearFieldName = memberFieldNames.find(f => { var _a; return (_a = schema.properties[f].tags) === null || _a === void 0 ? void 0 : _a.includes("date_component:year"); });
+                if (!dayFieldName || !monthFieldName || !yearFieldName) {
+                    throw new Error("Failed to infer date component field");
+                }
+                const isoString = [
+                    values[yearFieldName],
+                    `${values[monthFieldName]}`.padStart(2, "0"),
+                    `${values[dayFieldName]}`.padStart(2, "0"),
+                ].join("-");
+                const pseudoField = {
+                    hField: {
+                        __typeof__: helpers_1.HFieldSymbol,
+                        cameFromSchema: schemaName,
+                        verification: worstVer,
+                        verifiedBy: fieldVers,
+                    },
+                    type: "Date",
+                    value: new Date(isoString),
+                };
+                return [`__group_${groupName}`, pseudoField];
+            });
+            const deepProperties = Object.entries(PO.properties)
+                .filter(([fieldName, fieldValue]) => {
+                const field = schema.properties[fieldName];
+                return (field &&
+                    field.type === "object" &&
+                    field.properties &&
+                    fieldValue &&
+                    typeof fieldValue === "object");
+            })
+                .flatMap(([fieldName, fieldValue]) => {
+                const subFields = Object.keys(schema.properties[fieldName].properties);
+                return subFields.map(subFieldName => {
+                    const value = fieldValue[subFieldName];
+                    const hsubfield = {
+                        hField: null, // you can't access metadata on a subfield
+                        type: getTypeofFieldValue(value),
+                        value,
+                    };
+                    return [`${fieldName}|${subFieldName}`, hsubfield];
+                });
+            });
+            // eslint-disable-next-line fp/no-mutation
+            out[schemaName] || (out[schemaName] = []);
+            // eslint-disable-next-line fp/no-mutating-methods
+            out[schemaName].push({
+                hSchema: {
+                    __typeof__: helpers_1.HSchemaSymbol,
+                    verification: verified.status,
+                    verifiedBy: verified.details.verifiers
+                        .map(x => x.verifierNId)
+                        .filter((val) => !!val),
+                },
+                properties: Object.fromEntries([
+                    ...nonDateProperties,
+                    ...pseudoDateFields,
+                    ...deepProperties,
+                ]),
             });
-        });
-        // eslint-disable-next-line fp/no-mutation
-        out[schemaName] || (out[schemaName] = []);
-        // eslint-disable-next-line fp/no-mutating-methods
-        out[schemaName].push({
-            hSchema: {
-                __typeof__: helpers_1.HSchemaSymbol,
-                verification: verified.status,
-                verifiedBy: verified.details.verifiers
-                    .map(x => x.verifierNId)
-                    .filter((val) => !!val),
-            },
-            properties: Object.fromEntries([
-                ...nonDateProperties,
-                ...pseudoDateFields,
-                ...deepProperties,
-            ]),
-        });
+        }
     }
     return out;
 };

package/dist/rules/evaluateBadge.d.ts

@@ -0,0 +1,36 @@
+import type { BId, CommonFields } from "@raytio/types";
+import type { RuleData, ScoreConfig } from "./types";
+import type { ScoreResult } from "./calculateScore";
+/** Standard badge states - consistent across all badges */
+export type BadgeState = "not_met" | "partially_met" | "fully_met";
+/** Display configuration for a single badge state */
+export type BadgeStateDisplay = {
+    label: string;
+    color: string;
+    icon: string;
+};
+/** Badge definition as stored in dsm_schema_badges */
+export type BadgeDefinition = CommonFields<BId> & {
+    name: string;
+    display: {
+        states: Record<BadgeState, BadgeStateDisplay>;
+    };
+    ruleset: ScoreConfig;
+};
+/** Result of evaluating a badge for a user */
+export type BadgeResult = {
+    badgeId: string;
+    badgeName: string;
+    state: BadgeState;
+    display: BadgeStateDisplay;
+    diagnostics: ScoreResult["diagnostics"];
+};
+/**
+ * Evaluate a single badge definition against user data.
+ * Thin wrapper around calculateScore() -- threshold names map to badge states.
+ */
+export declare function evaluateBadge(badge: BadgeDefinition, ruleData: RuleData): Promise<BadgeResult>;
+/**
+ * Evaluate all active badge definitions against user data.
+ */
+export declare function evaluateUserBadges(badges: BadgeDefinition[], ruleData: RuleData): Promise<BadgeResult[]>;

package/dist/rules/evaluateBadge.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateBadge = evaluateBadge;
+exports.evaluateUserBadges = evaluateUserBadges;
+const calculateScore_1 = require("./calculateScore");
+const VALID_BADGE_STATES = [
+    "not_met",
+    "partially_met",
+    "fully_met",
+];
+/**
+ * Evaluate a single badge definition against user data.
+ * Thin wrapper around calculateScore() -- threshold names map to badge states.
+ */
+async function evaluateBadge(badge, ruleData) {
+    const scoreResult = await (0, calculateScore_1.calculateScore)(badge.ruleset, ruleData);
+    const state = scoreResult.category;
+    if (!VALID_BADGE_STATES.includes(state)) {
+        throw new Error(`Score category "${scoreResult.category}" is not a valid BadgeState. ` +
+            `Expected one of: ${VALID_BADGE_STATES.join(", ")}`);
+    }
+    return {
+        badgeId: badge.id,
+        badgeName: badge.name,
+        state,
+        display: badge.display.states[state],
+        diagnostics: scoreResult.diagnostics,
+    };
+}
+/**
+ * Evaluate all active badge definitions against user data.
+ */
+async function evaluateUserBadges(badges, ruleData) {
+    const active = badges.filter(b => b.active);
+    return Promise.all(active.map(b => evaluateBadge(b, ruleData)));
+}

package/dist/rules/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./calculateScore";
 export * from "./convertInstanceToRuleInput";
+export * from "./evaluateBadge";
 export * from "./validate";
 export * from "./types/config";
 export * from "./helpers/thresholds";

package/dist/rules/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.scoreOperators = void 0;
 __exportStar(require("./calculateScore"), exports);
 __exportStar(require("./convertInstanceToRuleInput"), exports);
+__exportStar(require("./evaluateBadge"), exports);
 __exportStar(require("./validate"), exports);
 __exportStar(require("./types/config"), exports);
 __exportStar(require("./helpers/thresholds"), exports);

package/dist/rules/types/config.d.ts

@@ -81,7 +81,7 @@ export type ScoreThreshold = {
      * A hex code, including the hash.
      * For compatibility reasons we must assume it could be missing
      */
-    colour: string | undefined;
+    colour: string | null | undefined;
 };
 /** @ignore */
 export type Combinator = "+" | "*";

package/dist/rules/types/dataValueTypes.d.ts

@@ -1,18 +1,18 @@
-import type { FieldVerification, NId, POVerification, SchemaName } from "@raytio/types";
+import type { FieldVerification, MId, POVerification, SchemaName } from "@raytio/types";
 import type { HFieldSymbol, HSchemaSymbol } from "../helpers";
 /** undefined if not shared */
 export type HField = {
     __typeof__: typeof HFieldSymbol;
     verification: FieldVerification;
-    verifiedBy: readonly NId[];
+    verifiedBy: readonly MId[];
     cameFromSchema: SchemaName;
 };
 /** undefined if not shared */
 export type HSchema = {
     __typeof__: typeof HSchemaSymbol;
     verification?: POVerification;
-    verifiedBy: readonly NId[];
+    verifiedBy: readonly MId[];
 };
 export declare const DATE_UNITS: readonly ["ms", "s", "m", "h", "D", "M", "W", "Y"];
 export type DateUnit = (typeof DATE_UNITS)[number];
-export type GetTSType<T> = T extends "Bool" ? boolean : T extends "Number" ? number : T extends "String" ? string : T extends "Date" ? Date : T extends "Array" ? unknown[] : T extends "HField" ? HField : T extends "HSchema" ? HSchema : T extends "DateUnit" ? DateUnit : T extends "RegEx" ? RegExp : T extends "Verifier" ? NId : T extends "FieldVerification" ? FieldVerification : T extends "POVerification" ? POVerification : never;
+export type GetTSType<T> = T extends "Bool" ? boolean : T extends "Number" ? number : T extends "String" ? string : T extends "Date" ? Date : T extends "Array" ? unknown[] : T extends "HField" ? HField : T extends "HSchema" ? HSchema : T extends "DateUnit" ? DateUnit : T extends "RegEx" ? RegExp : T extends "Verifier" ? MId : T extends "FieldVerification" ? FieldVerification : T extends "POVerification" ? POVerification : never;

package/dist/schema/expandSchema/constants.js

@@ -7,5 +7,5 @@ exports.TAG_DENYLIST = [
     "type:globally_unique_field",
     "type:marketplace",
     "type:service_offer",
-    "type:service_provider",
+    "type:merchant",
 ];

package/dist/schema/expandSchema/expandSchema.d.ts

@@ -1,7 +1,7 @@
-import type { Schema, WrappedSchema } from "@raytio/types";
+import type { FndI18nEntry, Schema, WrappedSchema } from "@raytio/types";
 /**
- * ❣️ This is the main function to transform a schema from
+ * This is the main function to transform a schema from
  * the JSON that the API returns, into a `Schema` object that's useful
  * to the client.
  */
-export declare function expandSchema(wrappedSchema: WrappedSchema, allUnexpandedSchemas: WrappedSchema[], userLocales: readonly string[]): Schema;
+export declare function expandSchema(wrappedSchema: WrappedSchema, allUnexpandedSchemas: WrappedSchema[], userLocales: readonly string[], fndI18nEntries?: FndI18nEntry[]): Schema;

package/dist/schema/expandSchema/expandSchema.js

@@ -7,12 +7,12 @@ const processSchema_1 = require("./processSchema");
 const removePrivateFields_1 = require("./removePrivateFields");
 const unwrapSchema_1 = require("./unwrapSchema");
 /**
- * ❣️ This is the main function to transform a schema from
+ * This is the main function to transform a schema from
  * the JSON that the API returns, into a `Schema` object that's useful
  * to the client.
  */
-function expandSchema(wrappedSchema, allUnexpandedSchemas, userLocales) {
-    // TODO: use Ramda's pipe
-    const schema = (0, removePrivateFields_1.removePrivateFields)((0, maybeUseI18n_1.maybeUseI18n)((0, addLoadingTimes_1.addLoadingTimes)((0, processSchema_1.processSchema)((0, unwrapSchema_1.unwrapSchema)(wrappedSchema), allUnexpandedSchemas)), userLocales));
+// eslint-disable-next-line max-params
+function expandSchema(wrappedSchema, allUnexpandedSchemas, userLocales, fndI18nEntries) {
+    const schema = (0, removePrivateFields_1.removePrivateFields)((0, maybeUseI18n_1.maybeUseI18n)((0, addLoadingTimes_1.addLoadingTimes)((0, processSchema_1.processSchema)((0, unwrapSchema_1.unwrapSchema)(wrappedSchema), allUnexpandedSchemas)), userLocales, fndI18nEntries));
     return Object.assign({ wasExpandedByClient: true }, schema);
 }

package/dist/schema/expandSchema/i18n.d.ts

@@ -1,5 +1,10 @@
 /**
  * Selects the most suitable locale to use from a list of options.
- * Returns undefined if there is no language that the user speaks
+ * Returns undefined if there is no language that the user speaks.
+ *
+ * Priority order:
+ * 1. Exact full locale match (e.g., user has en-NZ, schema has en-NZ)
+ * 2. Base language match (e.g., user has en-US, schema has en)
+ * 3. Any locale with matching base language (e.g., user has de-DE, schema has de-AT)
  */
 export declare const findSuitableLocale: (options: string[], langs: readonly string[]) => string | undefined;

package/dist/schema/expandSchema/i18n.js

@@ -10,11 +10,39 @@ const getAllLocales = (langs) => (0, ramda_1.uniq)(langs.flatMap(locale => [
 exports.getAllLocales = getAllLocales;
 /**
  * Selects the most suitable locale to use from a list of options.
- * Returns undefined if there is no language that the user speaks
+ * Returns undefined if there is no language that the user speaks.
+ *
+ * Priority order:
+ * 1. Exact full locale match (e.g., user has en-NZ, schema has en-NZ)
+ * 2. Base language match (e.g., user has en-US, schema has en)
+ * 3. Any locale with matching base language (e.g., user has de-DE, schema has de-AT)
  */
 const findSuitableLocale = (options, langs) => {
-    const userLocales = (0, exports.getAllLocales)(langs);
-    return (userLocales.find(locale => options.includes(locale)) ||
-        options.find(locale => userLocales.includes(locale.split("-")[0])));
+    // Get user's full locales (e.g., "en-NZ") in lowercase
+    const userFullLocales = langs.map(l => l.toLowerCase());
+    // Get user's base languages (e.g., "en") in lowercase
+    const userBaseLanguages = (0, ramda_1.uniq)(langs.map(l => l.toLowerCase().split("-")[0]));
+    // First, try to find an exact full locale match (case-insensitive)
+    // e.g., user has en-NZ, schema has en-NZ → returns "en-NZ"
+    for (const userLocale of userFullLocales) {
+        const match = options.find(opt => opt.toLowerCase() === userLocale);
+        if (match)
+            return match;
+    }
+    // Then, fall back to base language match
+    // e.g., user has en-US, schema has en → returns "en"
+    for (const baseLang of userBaseLanguages) {
+        const match = options.find(opt => opt.toLowerCase() === baseLang);
+        if (match)
+            return match;
+    }
+    // Finally, check if any option's base language matches user's base language
+    // e.g., user has de-DE, schema has de-AT → returns "de-AT"
+    for (const baseLang of userBaseLanguages) {
+        const match = options.find(opt => opt.toLowerCase().split("-")[0] === baseLang);
+        if (match)
+            return match;
+    }
+    return undefined;
 };
 exports.findSuitableLocale = findSuitableLocale;

package/dist/schema/expandSchema/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./expandSchema";
 export * from "./sortSchemaProperties";
+export * from "./constants";
 export { findSuitableLocale } from "./i18n";

package/dist/schema/expandSchema/index.js

@@ -17,5 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findSuitableLocale = void 0;
 __exportStar(require("./expandSchema"), exports);
 __exportStar(require("./sortSchemaProperties"), exports);
+__exportStar(require("./constants"), exports);
 var i18n_1 = require("./i18n");
 Object.defineProperty(exports, "findSuitableLocale", { enumerable: true, get: function () { return i18n_1.findSuitableLocale; } });

package/dist/schema/expandSchema/maybeUseI18n.d.ts

@@ -1,2 +1,2 @@
-import type { Schema } from "@raytio/types";
-export declare const maybeUseI18n: (schema: Schema, userLocales: readonly string[]) => Schema;
+import type { FndI18nEntry, Schema } from "@raytio/types";
+export declare const maybeUseI18n: (schema: Schema, userLocales: readonly string[], fndI18nEntries?: FndI18nEntry[]) => Schema;