@teincfood/core 0.1.0

package/dist/utils/error.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+exports.extractFromResponseBody = extractFromResponseBody;
+exports.extractApiErrorMessage = extractApiErrorMessage;
+exports.extractApiErrorCode = extractApiErrorCode;
+function extractFromResponseBody(data) {
+    const errorField = data.error;
+    if (errorField && typeof errorField === "object") {
+        const msg = errorField.message;
+        if (typeof msg === "string")
+            return msg;
+    }
+    if (typeof errorField === "string") {
+        if (data.message && typeof data.message === "string")
+            return data.message;
+        return errorField;
+    }
+    const errorsField = data.errors;
+    if (errorsField && typeof errorsField === "object") {
+        const detail = errorsField.detail;
+        if (typeof detail === "string")
+            return detail;
+    }
+    return null;
+}
+function extractApiErrorMessage(error) {
+    if (typeof error === "string")
+        return error;
+    if (!error || typeof error !== "object")
+        return "An unexpected error occurred";
+    const err = error;
+    const response = err.response;
+    if (response?.data && typeof response.data === "object") {
+        const msg = extractFromResponseBody(response.data);
+        if (msg)
+            return msg;
+    }
+    if (err.message && typeof err.message === "string") {
+        return err.message;
+    }
+    return "An unexpected error occurred";
+}
+function extractApiErrorCode(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    const err = error;
+    const response = err.response;
+    if (response?.data && typeof response.data === "object") {
+        const data = response.data;
+        const errorField = data.error;
+        if (errorField && typeof errorField === "object") {
+            const code = errorField.code;
+            if (typeof code === "string")
+                return code;
+        }
+        if (typeof errorField === "string")
+            return errorField;
+    }
+    if (err.data && typeof err.data === "object") {
+        const data = err.data;
+        const errorField = data.error;
+        if (errorField && typeof errorField === "object") {
+            const code = errorField.code;
+            if (typeof code === "string")
+                return code;
+        }
+    }
+    return undefined;
+}
+// Re-export ApiError from http adapter for compatibility
+var http_1 = require("../adapters/http");
+Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return http_1.ApiError; } });

package/dist/utils/formatCurrency.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Format a number as a currency string.
+ */
+export declare function formatCurrency(amount: number, currency?: string): string;

package/dist/utils/formatCurrency.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Format a number as a currency string.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCurrency = formatCurrency;
+function formatCurrency(amount, currency = "GHS") {
+    const amountMinor = Math.round(amount * 100);
+    // Simple region formatting — host apps can inject getRegionConfig via adapter if needed
+    const symbolMap = {
+        GHS: "GH₵",
+        USD: "$",
+    };
+    const symbol = symbolMap[currency] ?? currency;
+    return `${symbol}${(amountMinor / 100).toFixed(2)}`;
+}

package/dist/utils/formatDate.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Format an ISO date string into a human-readable format.
+ */
+export declare function formatDate(isoString: string, style?: 'short' | 'long'): string;
+/**
+ * Format a date as a relative time string (e.g., "20 min ago").
+ */
+export declare function formatRelativeTime(isoString: string): string;

package/dist/utils/formatDate.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDate = formatDate;
+exports.formatRelativeTime = formatRelativeTime;
+/**
+ * Format an ISO date string into a human-readable format.
+ */
+function formatDate(isoString, style = 'short') {
+    const date = new Date(isoString);
+    if (style === 'long') {
+        return date.toLocaleDateString('en-US', {
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric',
+        });
+    }
+    return date.toLocaleDateString('en-US', {
+        day: '2-digit',
+        month: '2-digit',
+        year: 'numeric',
+    });
+}
+/**
+ * Format a date as a relative time string (e.g., "20 min ago").
+ */
+function formatRelativeTime(isoString) {
+    const now = Date.now();
+    const then = new Date(isoString).getTime();
+    const diffMs = now - then;
+    const diffMin = Math.floor(diffMs / 60000);
+    if (diffMin < 1)
+        return 'Just now';
+    if (diffMin < 60)
+        return `${diffMin} min ago`;
+    const diffHours = Math.floor(diffMin / 60);
+    if (diffHours < 24)
+        return `${diffHours}h ago`;
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffDays < 7)
+        return `${diffDays}d ago`;
+    return formatDate(isoString);
+}

package/dist/utils/phone.d.ts

@@ -0,0 +1,10 @@
+export type PhoneCountryOption = {
+    iso: string;
+    name: string;
+    dialCode: string;
+};
+export declare const PHONE_COUNTRIES: PhoneCountryOption[];
+export declare function getDialCodeFromCountry(countryCode?: string): string | null;
+export declare function getCountryOption(iso?: string): PhoneCountryOption | null;
+export declare function normalizePhoneForCountry(rawPhone: string, countryCode?: string): string | null;
+export declare function isLikelyE164(phone: string): boolean;

package/dist/utils/phone.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PHONE_COUNTRIES = void 0;
+exports.getDialCodeFromCountry = getDialCodeFromCountry;
+exports.getCountryOption = getCountryOption;
+exports.normalizePhoneForCountry = normalizePhoneForCountry;
+exports.isLikelyE164 = isLikelyE164;
+exports.PHONE_COUNTRIES = [
+    { iso: 'GH', name: 'Ghana', dialCode: '+233' },
+    { iso: 'NG', name: 'Nigeria', dialCode: '+234' },
+    { iso: 'KE', name: 'Kenya', dialCode: '+254' },
+    { iso: 'ZA', name: 'South Africa', dialCode: '+27' },
+    { iso: 'US', name: 'United States', dialCode: '+1' },
+    { iso: 'CA', name: 'Canada', dialCode: '+1' },
+    { iso: 'GB', name: 'United Kingdom', dialCode: '+44' },
+    { iso: 'IN', name: 'India', dialCode: '+91' },
+    { iso: 'DE', name: 'Germany', dialCode: '+49' },
+    { iso: 'FR', name: 'France', dialCode: '+33' },
+    { iso: 'IT', name: 'Italy', dialCode: '+39' },
+    { iso: 'ES', name: 'Spain', dialCode: '+34' },
+    { iso: 'AE', name: 'United Arab Emirates', dialCode: '+971' },
+    { iso: 'SA', name: 'Saudi Arabia', dialCode: '+966' },
+];
+const COUNTRY_DIAL_CODE_BY_ISO = {
+    GH: '+233',
+    US: '+1',
+    CA: '+1',
+    GB: '+44',
+    NG: '+234',
+    KE: '+254',
+    ZA: '+27',
+    IN: '+91',
+    DE: '+49',
+    FR: '+33',
+    IT: '+39',
+    ES: '+34',
+    AE: '+971',
+    SA: '+966',
+};
+function digitsOnly(value) {
+    return value.replace(/\D/g, '');
+}
+function getDialCodeFromCountry(countryCode) {
+    if (!countryCode)
+        return null;
+    return COUNTRY_DIAL_CODE_BY_ISO[countryCode.trim().toUpperCase()] || null;
+}
+function getCountryOption(iso) {
+    if (!iso)
+        return null;
+    return exports.PHONE_COUNTRIES.find((country) => country.iso === iso.trim().toUpperCase()) || null;
+}
+function normalizePhoneForCountry(rawPhone, countryCode) {
+    const input = rawPhone.trim();
+    if (!input)
+        return null;
+    if (input.startsWith('+')) {
+        const normalized = `+${digitsOnly(input)}`;
+        return normalized;
+    }
+    const dialCode = getDialCodeFromCountry(countryCode);
+    if (!dialCode)
+        return null;
+    const localDigits = digitsOnly(input).replace(/^0+/, '');
+    if (!localDigits)
+        return null;
+    return `${dialCode}${localDigits}`;
+}
+function isLikelyE164(phone) {
+    return /^\+[1-9]\d{7,14}$/.test(phone);
+}

package/dist/utils/responsive.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Responsive helper — plain, no react-native.
+ * Host apps with RN can override via adapter; core provides window-based fallback.
+ */
+export interface ResponsiveState {
+    width: number;
+    height: number;
+    isTablet: boolean;
+    isLargeTablet: boolean;
+    isLandscape: boolean;
+    columns: (minItemWidth: number) => number;
+}
+export declare function useResponsive(): ResponsiveState;

package/dist/utils/responsive.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Responsive helper — plain, no react-native.
+ * Host apps with RN can override via adapter; core provides window-based fallback.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useResponsive = useResponsive;
+function getWindowSize() {
+    if (typeof window !== "undefined") {
+        return { width: window.innerWidth, height: window.innerHeight };
+    }
+    return { width: 1024, height: 768 };
+}
+function useResponsive() {
+    const { width, height } = getWindowSize();
+    const isTablet = width >= 768;
+    const isLandscape = width > height;
+    const isLargeTablet = width >= 1024;
+    const columns = (minItemWidth) => Math.max(1, Math.floor(width / minItemWidth));
+    return { width, height, isTablet, isLargeTablet, isLandscape, columns };
+}

package/dist/utils/storage.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Storage facade — re-exports KV adapter.
+ * Provides async JSON helpers and a zustand-compatible storage shim.
+ */
+export { getItem, setItem, removeItem, kvGetItem, kvSetItem, kvRemoveItem, setKVDriver, getKVDriver, } from "../adapters/kv";
+import type { StateStorage } from "../adapters/kv-types";
+export declare const mmkvStorage: {
+    getString: (_key: string) => string | null;
+    set: (_key: string, _value: string) => void;
+    delete: (_key: string) => void;
+};
+export declare const zustandStorage: StateStorage;
+export declare function getItemAsync<T>(key: string): Promise<T | null>;
+export declare function setItemAsync<T>(key: string, value: T): Promise<void>;
+export declare function removeItemAsync(key: string): Promise<void>;

package/dist/utils/storage.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Storage facade — re-exports KV adapter.
+ * Provides async JSON helpers and a zustand-compatible storage shim.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zustandStorage = exports.mmkvStorage = exports.getKVDriver = exports.setKVDriver = exports.kvRemoveItem = exports.kvSetItem = exports.kvGetItem = exports.removeItem = exports.setItem = exports.getItem = void 0;
+exports.getItemAsync = getItemAsync;
+exports.setItemAsync = setItemAsync;
+exports.removeItemAsync = removeItemAsync;
+var kv_1 = require("../adapters/kv");
+Object.defineProperty(exports, "getItem", { enumerable: true, get: function () { return kv_1.getItem; } });
+Object.defineProperty(exports, "setItem", { enumerable: true, get: function () { return kv_1.setItem; } });
+Object.defineProperty(exports, "removeItem", { enumerable: true, get: function () { return kv_1.removeItem; } });
+Object.defineProperty(exports, "kvGetItem", { enumerable: true, get: function () { return kv_1.kvGetItem; } });
+Object.defineProperty(exports, "kvSetItem", { enumerable: true, get: function () { return kv_1.kvSetItem; } });
+Object.defineProperty(exports, "kvRemoveItem", { enumerable: true, get: function () { return kv_1.kvRemoveItem; } });
+Object.defineProperty(exports, "setKVDriver", { enumerable: true, get: function () { return kv_1.setKVDriver; } });
+Object.defineProperty(exports, "getKVDriver", { enumerable: true, get: function () { return kv_1.getKVDriver; } });
+const kv_2 = require("../adapters/kv");
+const kv_3 = require("../adapters/kv");
+// Keep mmkvStorage export for backwards compat (no-op)
+exports.mmkvStorage = {
+    getString: (_key) => null,
+    set: (_key, _value) => { },
+    delete: (_key) => { },
+};
+exports.zustandStorage = {
+    getItem: (name) => {
+        const v = (0, kv_3.getItemSync)(name);
+        return v ? JSON.stringify(v) : null;
+    },
+    setItem: (name, value) => {
+        try {
+            (0, kv_3.setItemSync)(name, JSON.parse(value));
+        }
+        catch { }
+    },
+    removeItem: (name) => {
+        (0, kv_3.removeItemSync)(name);
+    },
+};
+// Async helpers for code that expects promise-based storage (used by order-number, etc.)
+async function getItemAsync(key) {
+    const raw = await (0, kv_2.kvGetItem)(key);
+    if (raw == null)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function setItemAsync(key, value) {
+    await (0, kv_2.kvSetItem)(key, JSON.stringify(value));
+}
+async function removeItemAsync(key) {
+    await (0, kv_2.kvRemoveItem)(key);
+}

package/dist/utils/sync-logger.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Structured logging for the Sync Engine, commands, events, and transports.
+ *
+ * Logs are sent to console.debug in debug builds. In production this can be
+ * swapped for a crashlytics/analytics sink without changing call sites.
+ */
+import type { Command, DomainEvent, Transport } from "../sync/types";
+declare class SyncLogger {
+    private enabled;
+    constructor();
+    setEnabled(enabled: boolean): void;
+    private log;
+    debug: (namespace: string, message: string, data?: Record<string, unknown>) => void;
+    info: (namespace: string, message: string, data?: Record<string, unknown>) => void;
+    warn: (namespace: string, message: string, data?: Record<string, unknown>) => void;
+    error: (namespace: string, message: string, data?: Record<string, unknown>) => void;
+    command(command: Command, action: "issued" | "queued" | "executing" | "completed" | "failed", data?: Record<string, unknown>): void;
+    event(event: DomainEvent, action: "received" | "persisted" | "applied" | "broadcast", data?: Record<string, unknown>): void;
+    transport(transport: Pick<Transport, "name">, action: "available" | "unavailable" | "executing" | "completed" | "error", data?: Record<string, unknown>): void;
+}
+export declare const syncLogger: SyncLogger;
+export {};

package/dist/utils/sync-logger.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Structured logging for the Sync Engine, commands, events, and transports.
+ *
+ * Logs are sent to console.debug in debug builds. In production this can be
+ * swapped for a crashlytics/analytics sink without changing call sites.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncLogger = void 0;
+function emit(entry) {
+    const { level, namespace, message, data } = entry;
+    const tag = `[${namespace}] ${message}`;
+    switch (level) {
+        case "debug":
+            console.debug(tag, data);
+            break;
+        case "info":
+            console.info(tag, data);
+            break;
+        case "warn":
+            console.warn(tag, data);
+            break;
+        case "error":
+            console.error(tag, data);
+            break;
+    }
+}
+class SyncLogger {
+    constructor() {
+        this.debug = (namespace, message, data) => this.log("debug", namespace, message, data);
+        this.info = (namespace, message, data) => this.log("info", namespace, message, data);
+        this.warn = (namespace, message, data) => this.log("warn", namespace, message, data);
+        this.error = (namespace, message, data) => this.log("error", namespace, message, data);
+        try {
+            this.enabled = typeof __DEV__ !== "undefined" ? __DEV__ : process.env.NODE_ENV !== "production";
+        }
+        catch {
+            this.enabled = process.env.NODE_ENV !== "production";
+        }
+    }
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+    log(level, namespace, message, data) {
+        if (!this.enabled)
+            return;
+        emit({
+            level,
+            namespace,
+            message,
+            data,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    command(command, action, data) {
+        this.debug("SyncEngine:Command", `Command ${action}`, {
+            command_id: command.command_id,
+            command_type: command.command_type,
+            business_id: command.business_id,
+            entity_id: command.entity_id,
+            ...data,
+        });
+    }
+    event(event, action, data) {
+        this.debug("SyncEngine:Event", `Event ${action}`, {
+            event_id: event.event_id,
+            event_type: event.event_type,
+            entity_id: event.entity_id,
+            ...data,
+        });
+    }
+    transport(transport, action, data) {
+        this.debug("SyncEngine:Transport", `Transport ${action}`, {
+            transport: transport.name,
+            ...data,
+        });
+    }
+}
+exports.syncLogger = new SyncLogger();

package/dist/utils/uuid.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Client-side UUID generation — plain JS, no expo-crypto.
+ */
+export declare function generateUUID(): string;
+export declare function generateCommandId(): string;
+export declare function generateEventId(): string;
+export declare function generateEntityId(): string;

package/dist/utils/uuid.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Client-side UUID generation — plain JS, no expo-crypto.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUUID = generateUUID;
+exports.generateCommandId = generateCommandId;
+exports.generateEventId = generateEventId;
+exports.generateEntityId = generateEntityId;
+function randomHex(bytes) {
+    const arr = new Uint8Array(bytes);
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+        crypto.getRandomValues(arr);
+    }
+    else {
+        for (let i = 0; i < bytes; i++)
+            arr[i] = Math.floor(Math.random() * 256);
+    }
+    return Array.from(arr, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function uuidV4() {
+    const hex = randomHex(16);
+    // Set version 4 and variant bits per RFC4122
+    return (hex.slice(0, 8) +
+        "-" +
+        hex.slice(8, 12) +
+        "-" +
+        "4" +
+        hex.slice(13, 16) +
+        "-" +
+        ((parseInt(hex[16], 16) & 0x3) | 0x8).toString(16) +
+        hex.slice(17, 20) +
+        "-" +
+        hex.slice(20, 32));
+}
+function generateUUID() {
+    return uuidV4();
+}
+function generateCommandId() {
+    return `cmd_${uuidV4()}`;
+}
+function generateEventId() {
+    return `evt_${uuidV4()}`;
+}
+function generateEntityId() {
+    return uuidV4();
+}

package/dist/utils/validation.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Validation Utilities
+ * Provides schema validation for REST/WS/SSE/push payloads
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export declare function validateEmail(email: string): ValidationResult;
+export declare function validatePhone(phone: string): ValidationResult;
+export declare function validateUsername(username: string): ValidationResult;
+export declare function validatePassword(password: string): ValidationResult;
+export declare function validateOrderPayload(payload: unknown): ValidationResult;
+export declare function validateChatMessage(payload: unknown): ValidationResult;
+export declare function validateEventEnvelope(payload: unknown): ValidationResult;
+export declare function validatePromoCode(code: string): ValidationResult;
+export declare function validateAddress(address: Record<string, unknown>): ValidationResult;
+export declare function validatePaymentMethod(payment: Record<string, unknown>): ValidationResult;
+export declare const validation: {
+    isNotEmpty: (value: string) => boolean;
+    isValid: (value: string, validator: (v: string) => ValidationResult) => boolean;
+    email: ((v: string) => ValidationResult) & {
+        message: string;
+    };
+    phone: ((v: string) => ValidationResult) & {
+        message: string;
+    };
+    password: ((v: string) => ValidationResult) & {
+        message: string;
+    };
+};