@myrjfa/state 0.3.1

package/dist/lib/userAtom.d.ts

@@ -0,0 +1,294 @@
+export declare const storageInitializedAtom: import("jotai").PrimitiveAtom<boolean> & {
+    init: boolean;
+};
+export declare const userAtom: import("jotai").WritableAtom<{
+    username: string;
+    firstName: string;
+    lastName: string;
+    email: string;
+    password: string;
+    phoneNumber: string;
+    countryCode: string;
+    country: string;
+    gender: "male" | "female" | "other";
+    rating: number;
+    ratingCount: number;
+    reviewCount: number;
+    joinedDate: Date;
+    isActive: boolean;
+    lastActive: Date;
+    verifiedEmail: boolean;
+    verifiedMobile: boolean;
+    role: string;
+    _id?: string | undefined;
+    location?: string | undefined;
+    pinCode?: string | undefined;
+    dob?: Date | undefined;
+    profilePic?: string | undefined;
+    blogsCount?: number | undefined;
+    userBio?: string | undefined;
+    userIdCard?: string | undefined;
+    watchHistory?: string[] | undefined;
+    accessToken?: string | undefined;
+    refreshToken?: string | undefined;
+    verifiedIdCard?: boolean | undefined;
+    permissions?: string[] | undefined;
+    accountType?: "user" | "host" | "staff" | undefined;
+    baseAccountType?: "user" | "host" | undefined;
+    legacyRole?: string | undefined;
+    staffProfileId?: string | null | undefined;
+    baseUserId?: string | null | undefined;
+    baseHostId?: string | null | undefined;
+    socialLinks?: Partial<Record<"instagram" | "linkedin" | "youtube" | "googleBusiness", string>> | undefined;
+    userResume?: string | undefined;
+    skills?: {
+        skill: string;
+        skillExpertise: number;
+    }[] | undefined;
+    wishlist?: string[] | undefined;
+    favBlogs?: string[] | undefined;
+    favPackages?: string[] | undefined;
+    id?: string | undefined;
+    selfie?: string | undefined;
+    selfieAction?: string | undefined;
+    jobCount?: number | undefined;
+    travelPackageCount?: number | undefined;
+    gstNumber?: string | undefined;
+    panCard?: string | undefined;
+    verifiedBusiness?: "true" | "false" | "inProgress" | undefined;
+    properties?: {
+        country: string;
+        type: string;
+        name: string;
+        address: string;
+        city: string;
+        state: string;
+        pinCode?: string | undefined;
+        registrationNumber?: string | undefined;
+    }[] | undefined;
+    businessDocument?: string | undefined;
+    businessIdType?: "PAN" | "GST" | "Udyam" | "PersonalPAN" | undefined;
+    businessIdNumber?: string | undefined;
+    businessApiVerificationStatus?: "pending" | "verified" | "failed" | undefined;
+    businessVerificationDenialReason?: string | undefined;
+} | null, [{
+    username: string;
+    firstName: string;
+    lastName: string;
+    email: string;
+    password: string;
+    phoneNumber: string;
+    countryCode: string;
+    country: string;
+    gender: "male" | "female" | "other";
+    rating: number;
+    ratingCount: number;
+    reviewCount: number;
+    joinedDate: Date;
+    isActive: boolean;
+    lastActive: Date;
+    verifiedEmail: boolean;
+    verifiedMobile: boolean;
+    role: string;
+    _id?: string | undefined;
+    location?: string | undefined;
+    pinCode?: string | undefined;
+    dob?: Date | undefined;
+    profilePic?: string | undefined;
+    blogsCount?: number | undefined;
+    userBio?: string | undefined;
+    userIdCard?: string | undefined;
+    watchHistory?: string[] | undefined;
+    accessToken?: string | undefined;
+    refreshToken?: string | undefined;
+    verifiedIdCard?: boolean | undefined;
+    permissions?: string[] | undefined;
+    accountType?: "user" | "host" | "staff" | undefined;
+    baseAccountType?: "user" | "host" | undefined;
+    legacyRole?: string | undefined;
+    staffProfileId?: string | null | undefined;
+    baseUserId?: string | null | undefined;
+    baseHostId?: string | null | undefined;
+    socialLinks?: Partial<Record<"instagram" | "linkedin" | "youtube" | "googleBusiness", string>> | undefined;
+    userResume?: string | undefined;
+    skills?: {
+        skill: string;
+        skillExpertise: number;
+    }[] | undefined;
+    wishlist?: string[] | undefined;
+    favBlogs?: string[] | undefined;
+    favPackages?: string[] | undefined;
+    id?: string | undefined;
+    selfie?: string | undefined;
+    selfieAction?: string | undefined;
+    jobCount?: number | undefined;
+    travelPackageCount?: number | undefined;
+    gstNumber?: string | undefined;
+    panCard?: string | undefined;
+    verifiedBusiness?: "true" | "false" | "inProgress" | undefined;
+    properties?: {
+        country: string;
+        type: string;
+        name: string;
+        address: string;
+        city: string;
+        state: string;
+        pinCode?: string | undefined;
+        registrationNumber?: string | undefined;
+    }[] | undefined;
+    businessDocument?: string | undefined;
+    businessIdType?: "PAN" | "GST" | "Udyam" | "PersonalPAN" | undefined;
+    businessIdNumber?: string | undefined;
+    businessApiVerificationStatus?: "pending" | "verified" | "failed" | undefined;
+    businessVerificationDenialReason?: string | undefined;
+} | typeof import("jotai/utils").RESET | ((prev: {
+    username: string;
+    firstName: string;
+    lastName: string;
+    email: string;
+    password: string;
+    phoneNumber: string;
+    countryCode: string;
+    country: string;
+    gender: "male" | "female" | "other";
+    rating: number;
+    ratingCount: number;
+    reviewCount: number;
+    joinedDate: Date;
+    isActive: boolean;
+    lastActive: Date;
+    verifiedEmail: boolean;
+    verifiedMobile: boolean;
+    role: string;
+    _id?: string | undefined;
+    location?: string | undefined;
+    pinCode?: string | undefined;
+    dob?: Date | undefined;
+    profilePic?: string | undefined;
+    blogsCount?: number | undefined;
+    userBio?: string | undefined;
+    userIdCard?: string | undefined;
+    watchHistory?: string[] | undefined;
+    accessToken?: string | undefined;
+    refreshToken?: string | undefined;
+    verifiedIdCard?: boolean | undefined;
+    permissions?: string[] | undefined;
+    accountType?: "user" | "host" | "staff" | undefined;
+    baseAccountType?: "user" | "host" | undefined;
+    legacyRole?: string | undefined;
+    staffProfileId?: string | null | undefined;
+    baseUserId?: string | null | undefined;
+    baseHostId?: string | null | undefined;
+    socialLinks?: Partial<Record<"instagram" | "linkedin" | "youtube" | "googleBusiness", string>> | undefined;
+    userResume?: string | undefined;
+    skills?: {
+        skill: string;
+        skillExpertise: number;
+    }[] | undefined;
+    wishlist?: string[] | undefined;
+    favBlogs?: string[] | undefined;
+    favPackages?: string[] | undefined;
+    id?: string | undefined;
+    selfie?: string | undefined;
+    selfieAction?: string | undefined;
+    jobCount?: number | undefined;
+    travelPackageCount?: number | undefined;
+    gstNumber?: string | undefined;
+    panCard?: string | undefined;
+    verifiedBusiness?: "true" | "false" | "inProgress" | undefined;
+    properties?: {
+        country: string;
+        type: string;
+        name: string;
+        address: string;
+        city: string;
+        state: string;
+        pinCode?: string | undefined;
+        registrationNumber?: string | undefined;
+    }[] | undefined;
+    businessDocument?: string | undefined;
+    businessIdType?: "PAN" | "GST" | "Udyam" | "PersonalPAN" | undefined;
+    businessIdNumber?: string | undefined;
+    businessApiVerificationStatus?: "pending" | "verified" | "failed" | undefined;
+    businessVerificationDenialReason?: string | undefined;
+} | null) => {
+    username: string;
+    firstName: string;
+    lastName: string;
+    email: string;
+    password: string;
+    phoneNumber: string;
+    countryCode: string;
+    country: string;
+    gender: "male" | "female" | "other";
+    rating: number;
+    ratingCount: number;
+    reviewCount: number;
+    joinedDate: Date;
+    isActive: boolean;
+    lastActive: Date;
+    verifiedEmail: boolean;
+    verifiedMobile: boolean;
+    role: string;
+    _id?: string | undefined;
+    location?: string | undefined;
+    pinCode?: string | undefined;
+    dob?: Date | undefined;
+    profilePic?: string | undefined;
+    blogsCount?: number | undefined;
+    userBio?: string | undefined;
+    userIdCard?: string | undefined;
+    watchHistory?: string[] | undefined;
+    accessToken?: string | undefined;
+    refreshToken?: string | undefined;
+    verifiedIdCard?: boolean | undefined;
+    permissions?: string[] | undefined;
+    accountType?: "user" | "host" | "staff" | undefined;
+    baseAccountType?: "user" | "host" | undefined;
+    legacyRole?: string | undefined;
+    staffProfileId?: string | null | undefined;
+    baseUserId?: string | null | undefined;
+    baseHostId?: string | null | undefined;
+    socialLinks?: Partial<Record<"instagram" | "linkedin" | "youtube" | "googleBusiness", string>> | undefined;
+    userResume?: string | undefined;
+    skills?: {
+        skill: string;
+        skillExpertise: number;
+    }[] | undefined;
+    wishlist?: string[] | undefined;
+    favBlogs?: string[] | undefined;
+    favPackages?: string[] | undefined;
+    id?: string | undefined;
+    selfie?: string | undefined;
+    selfieAction?: string | undefined;
+    jobCount?: number | undefined;
+    travelPackageCount?: number | undefined;
+    gstNumber?: string | undefined;
+    panCard?: string | undefined;
+    verifiedBusiness?: "true" | "false" | "inProgress" | undefined;
+    properties?: {
+        country: string;
+        type: string;
+        name: string;
+        address: string;
+        city: string;
+        state: string;
+        pinCode?: string | undefined;
+        registrationNumber?: string | undefined;
+    }[] | undefined;
+    businessDocument?: string | undefined;
+    businessIdType?: "PAN" | "GST" | "Udyam" | "PersonalPAN" | undefined;
+    businessIdNumber?: string | undefined;
+    businessApiVerificationStatus?: "pending" | "verified" | "failed" | undefined;
+    businessVerificationDenialReason?: string | undefined;
+} | typeof import("jotai/utils").RESET | null) | null], void>;
+export declare const isLoggedInAtom: import("jotai").WritableAtom<boolean, [boolean | typeof import("jotai/utils").RESET | ((prev: boolean) => boolean | typeof import("jotai/utils").RESET)], void>;
+export declare const userLoadingAtom: import("jotai").Atom<boolean>;
+export declare const initializeAuthSessionAtom: import("jotai").WritableAtom<null, [], Promise<void>> & {
+    init: null;
+};
+export declare const resetAuthStateAtom: import("jotai").WritableAtom<null, [], void> & {
+    init: null;
+};
+export declare function resetAuthState(): void;
+//# sourceMappingURL=userAtom.d.ts.map

package/dist/lib/userAtom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"userAtom.d.ts","sourceRoot":"","sources":["../../src/lib/userAtom.ts"],"names":[],"mappings":"AAgEA,eAAO,MAAM,sBAAsB;;CAAuB,CAAC;AAG3D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6DAQpB,CAAC;AAEF,eAAO,MAAM,cAAc,iKAA6C,CAAC;AAGzE,eAAO,MAAM,eAAe,+BAM1B,CAAC;AAGH,eAAO,MAAM,yBAAyB;;CA+CrC,CAAC;AAEF,eAAO,MAAM,kBAAkB;;CAO7B,CAAC;AAEH,wBAAgB,cAAc,SAU7B"}

package/dist/lib/userAtom.js

@@ -0,0 +1,139 @@
+// atoms/userAtom.ts
+import CryptoJS from 'crypto-js';
+import { atom, getDefaultStore } from 'jotai';
+import { atomWithStorage } from 'jotai/utils';
+import { getCurrentUser } from './actions/actions';
+const STORAGE_KEY = process.env.NEXT_PUBLIC_USER_KEY;
+const LOGIN_KEY = process.env.NEXT_PUBLIC_LOGIN_KEY;
+const SECRET_KEY = process.env.NEXT_PUBLIC_RACE;
+const EXPIRY_DAYS = 90;
+const EXPIRY_MS = EXPIRY_DAYS * 24 * 60 * 60 * 1000;
+const store = getDefaultStore();
+// 🔐 Encryption
+const encrypt = (data) => CryptoJS.AES.encrypt(JSON.stringify(data), SECRET_KEY).toString();
+const decrypt = (cipher) => {
+    try {
+        const bytes = CryptoJS.AES.decrypt(cipher, SECRET_KEY);
+        const decrypted = bytes.toString(CryptoJS.enc.Utf8);
+        return JSON.parse(decrypted);
+    }
+    catch (e) {
+        console.warn('Decryption failed:', e);
+        return null;
+    }
+};
+// 🧠 Wrap expiry in localStorage
+const getWithExpiry = (key) => {
+    if (typeof window === 'undefined')
+        return null;
+    try {
+        const raw = localStorage.getItem(key);
+        if (!raw)
+            return null;
+        const data = decrypt(raw);
+        if (!data)
+            return null;
+        const { value, expiry } = data;
+        if (Date.now() > expiry) {
+            resetAuthState();
+            return null;
+        }
+        return value;
+    }
+    catch (e) {
+        console.warn('Invalid user data:', e);
+        resetAuthState();
+        return null;
+    }
+};
+const setWithExpiry = (key, value) => {
+    if (typeof window === 'undefined')
+        return null;
+    if (!value)
+        return localStorage.removeItem(key);
+    const expiry = Date.now() + EXPIRY_MS;
+    const encrypted = encrypt({ value, expiry });
+    localStorage.setItem(key, encrypted);
+};
+// Storage initialization atom - tracks if we've tried to load from storage
+export const storageInitializedAtom = atom(false);
+// 🍱 Base storage atom (persisted)
+export const userAtom = atomWithStorage(STORAGE_KEY, null, {
+    getItem: (key) => getWithExpiry(key),
+    setItem: setWithExpiry,
+    removeItem: (key) => localStorage.removeItem(key),
+});
+export const isLoggedInAtom = atomWithStorage(LOGIN_KEY, false);
+// 🕒 Tracks if user is loading
+export const userLoadingAtom = atom((get) => {
+    // The issue was here - we need to properly track initialization state
+    const initialized = get(storageInitializedAtom);
+    // We're loading if we haven't initialized storage yet
+    return !initialized;
+});
+// Initialize storage atom effect
+export const initializeAuthSessionAtom = atom(null, async (get, set) => {
+    // Only run in browser
+    if (typeof window === 'undefined')
+        return;
+    // 1. Validate session (role-aware — host route differs from user route)
+    // const session = await validateSession();
+    // if (session.success) {
+    // Session validated successfully
+    // } else {
+    //     resetAuthState();
+    //     set(storageInitializedAtom, true);
+    //     return;
+    // }
+    // NOTE: if validateSession fails we do NOT reset — we just fall through
+    // to cache/API. A failed ping could mean the backend is temporarily down,
+    // the user is a host (different endpoint), etc. We only clear state if we
+    // POSITIVELY know the user is logged out (getCurrentUser fails).
+    // 2. Try cache (localStorage)
+    const userData = getWithExpiry(STORAGE_KEY);
+    if (userData) {
+        set(userAtom, userData);
+        set(isLoggedInAtom, true);
+        set(storageInitializedAtom, true);
+        return;
+    }
+    // 3. If cache miss: fetch user from backend using session cookie
+    try {
+        // This endpoint can hit DB or another cache as needed
+        const remoteUser = await getCurrentUser();
+        if (remoteUser) {
+            set(userAtom, remoteUser);
+            set(isLoggedInAtom, true);
+            setWithExpiry(STORAGE_KEY, remoteUser); // Write to local cache for next time
+        }
+        else {
+            resetAuthState();
+        }
+    }
+    catch {
+        resetAuthState();
+    }
+    finally {
+        set(storageInitializedAtom, true);
+    }
+});
+export const resetAuthStateAtom = atom(null, (_get, set) => {
+    if (typeof window === 'undefined')
+        return;
+    localStorage.removeItem(STORAGE_KEY);
+    localStorage.removeItem(LOGIN_KEY);
+    set(userAtom, null);
+    set(isLoggedInAtom, false);
+    set(storageInitializedAtom, true);
+});
+export function resetAuthState() {
+    if (typeof window === 'undefined') {
+        console.warn('resetAuthState called on server — skipped');
+        return;
+    }
+    localStorage.removeItem(STORAGE_KEY);
+    localStorage.removeItem(LOGIN_KEY);
+    store.set(userAtom, null);
+    store.set(isLoggedInAtom, false);
+    store.set(storageInitializedAtom, true);
+}

package/dist/lib/util.d.ts

@@ -0,0 +1,11 @@
+import { Blog } from "@myrjfa/state/dist/lib/models/blog";
+import { TileProps } from "@myrjfa/state/dist/lib/models/tile";
+import { User } from "@myrjfa/state/dist/lib/models/user";
+import { TravelPackage } from "@myrjfa/state/dist/lib/models/package";
+import { Opportunity } from "@myrjfa/state/dist/lib/models/opportunities/opportunity";
+export declare const expertiseLevels: string[];
+export declare function incompleteMVP(user?: User): string[];
+export declare function convertOpportunityToTileProps(opportunity: Opportunity): TileProps;
+export declare function convertBlogToTileProps(blog: Blog): TileProps;
+export declare function convertTravelPackageToTileProps(travelPackage: TravelPackage): TileProps;
+//# sourceMappingURL=util.d.ts.map

package/dist/lib/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/lib/util.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AACtE,OAAO,EAAE,WAAW,EAAgB,MAAM,yDAAyD,CAAC;AAIpG,eAAO,MAAM,eAAe,UAA0D,CAAC;AAEvF,wBAAgB,aAAa,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,MAAM,EAAE,CAanD;AAED,wBAAgB,6BAA6B,CAAC,WAAW,EAAE,WAAW,GAAG,SAAS,CAgBjF;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,CAgB5D;AAED,wBAAgB,+BAA+B,CAAC,aAAa,EAAE,aAAa,GAAG,SAAS,CAuBvF"}

package/dist/lib/util.js

@@ -0,0 +1,82 @@
+import { truncateText } from "@myrjfa/state/dist/lib/utils";
+import { calculatePricingStrategyDisplayUnitPrice, getPricingCurrency, getPricingStrategies } from "@myrjfa/state/dist/lib/models/pricing";
+export const expertiseLevels = ["none", "basic", "intermediate", "advanced", "expert"];
+export function incompleteMVP(user) {
+    const incompletions = [];
+    if (user) {
+        if (!user.verifiedIdCard)
+            incompletions.push("Verify your id card");
+        if (!user.skills || user.skills.length == 0)
+            incompletions.push("Your skills");
+        if (!user.userResume)
+            incompletions.push("Profile Default Resume");
+        if (!user.location)
+            incompletions.push("your location");
+        if (!user.pinCode)
+            incompletions.push("PinCode");
+        if (!user.profilePic)
+            incompletions.push("Proile Pic");
+    }
+    else {
+        incompletions.push("Please login first");
+    }
+    return incompletions;
+}
+export function convertOpportunityToTileProps(opportunity) {
+    return {
+        slug: opportunity.slug || '',
+        image: opportunity.images?.[0] || "/images/placeholder.svg",
+        title: opportunity.title || '',
+        description: opportunity.description || '',
+        location: opportunity.city + ', ' + opportunity.state || '',
+        date: opportunity.createdAt || new Date(),
+        rating: opportunity.rating,
+        skills: opportunity.skills || [],
+        className: opportunity.categoryId,
+        duration: opportunity.minDuration,
+        maxDuration: opportunity.maxDuration,
+        opportunityType: opportunity.opportunityType || 'volunteer',
+        payFrequency: opportunity.compensation?.frequency || undefined,
+    };
+}
+export function convertBlogToTileProps(blog) {
+    return {
+        slug: blog.slug || '',
+        image: blog.blogImages?.[0] || "/images/placeholder.svg",
+        title: blog.title || '',
+        description: truncateText(blog.overview, 150),
+        location: '',
+        date: blog.createdAt,
+        rating: blog.likes || 0,
+        skills: [],
+        className: '',
+        host: blog.author ? {
+            name: blog.author,
+            image: blog.authorImage
+        } : undefined,
+    };
+}
+export function convertTravelPackageToTileProps(travelPackage) {
+    return {
+        slug: travelPackage.slug || '',
+        image: travelPackage.packageImages?.[0] || "/images/placeholder.svg",
+        title: travelPackage.title || '',
+        description: '',
+        tileType: "packages",
+        location: travelPackage.city + ', ' + travelPackage.state || '',
+        date: travelPackage.createdAt instanceof Date ? travelPackage.createdAt : new Date(travelPackage.createdAt),
+        rating: travelPackage.rating,
+        className: travelPackage.categoryId,
+        price: calculatePricingStrategyDisplayUnitPrice(getPricingStrategies(travelPackage)?.[0]),
+        currency: getPricingCurrency(travelPackage),
+        duration: travelPackage.duration,
+        difficultyLevel: travelPackage.difficultyLevel,
+        host: travelPackage.host?.name ? {
+            image: travelPackage.host?.image ?? "/images/profile_placeholder.webp",
+            name: travelPackage.host?.name,
+        } : {
+            image: travelPackage.hostId?.profilePic ?? "/images/profile_placeholder.webp",
+            name: travelPackage.hostId?.username,
+        }
+    };
+}

package/dist/lib/utils/entitySubmission.d.ts

@@ -0,0 +1,21 @@
+type SubmissionResult = {
+    success?: boolean;
+    error?: string;
+    slug?: string;
+};
+type HandleEntitySubmissionResultOptions = {
+    result: SubmissionResult;
+    isEditing: boolean;
+    editSlug?: string | null;
+    clearDraft: () => void;
+    setDone: (value: {
+        slug: string;
+        asDraft?: boolean;
+    }) => void;
+    setSubmitError: (message: string) => void;
+    asDraft: boolean;
+    defaultError: string;
+};
+export declare function handleEntitySubmissionResult({ result, isEditing, editSlug, clearDraft, setDone, setSubmitError, asDraft, defaultError, }: HandleEntitySubmissionResultOptions): boolean;
+export {};
+//# sourceMappingURL=entitySubmission.d.ts.map

package/dist/lib/utils/entitySubmission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entitySubmission.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/entitySubmission.ts"],"names":[],"mappings":"AAAA,KAAK,gBAAgB,GAAG;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,mCAAmC,GAAG;IACzC,MAAM,EAAE,gBAAgB,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,OAAO,EAAE,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC9D,cAAc,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,EAC3C,MAAM,EACN,SAAS,EACT,QAAQ,EACR,UAAU,EACV,OAAO,EACP,cAAc,EACd,OAAO,EACP,YAAY,GACb,EAAE,mCAAmC,WAUrC"}

package/dist/lib/utils/entitySubmission.js

@@ -0,0 +1,10 @@
+export function handleEntitySubmissionResult({ result, isEditing, editSlug, clearDraft, setDone, setSubmitError, asDraft, defaultError, }) {
+    if (result.success) {
+        clearDraft();
+        const finalSlug = isEditing ? editSlug : result.slug;
+        setDone({ slug: finalSlug || "", asDraft });
+        return true;
+    }
+    setSubmitError(result.error || defaultError);
+    return false;
+}

package/dist/lib/utils/fileCompression.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Utility for client-side file compression before upload.
+ */
+interface CompressionOptions {
+    maxWidth?: number;
+    maxHeight?: number;
+    quality?: number;
+    mimeType?: string;
+}
+export declare function compressImage(file: File, options?: CompressionOptions): Promise<File>;
+/**
+ * Checks if a file is an image that can be compressed.
+ */
+export declare function isCompressibleImage(file: File): boolean;
+export {};
+//# sourceMappingURL=fileCompression.d.ts.map

package/dist/lib/utils/fileCompression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileCompression.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/fileCompression.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,UAAU,kBAAkB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+D/F;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAEvD"}

package/dist/lib/utils/fileCompression.js

@@ -0,0 +1,56 @@
+/**
+ * Utility for client-side file compression before upload.
+ */
+export async function compressImage(file, options = {}) {
+    const { maxWidth = 1920, maxHeight = 1080, quality = 0.2, mimeType = "image/jpeg" } = options;
+    return new Promise((resolve, reject) => {
+        const img = new Image();
+        img.src = URL.createObjectURL(file);
+        img.onload = () => {
+            URL.revokeObjectURL(img.src);
+            const canvas = document.createElement("canvas");
+            let width = img.width;
+            let height = img.height;
+            // Maintain aspect ratio
+            if (width > height) {
+                if (width > maxWidth) {
+                    height *= maxWidth / width;
+                    width = maxWidth;
+                }
+            }
+            else {
+                if (height > maxHeight) {
+                    width *= maxHeight / height;
+                    height = maxHeight;
+                }
+            }
+            canvas.width = width;
+            canvas.height = height;
+            const ctx = canvas.getContext("2d");
+            if (!ctx) {
+                return reject(new Error("Could not get canvas context"));
+            }
+            ctx.drawImage(img, 0, 0, width, height);
+            canvas.toBlob((blob) => {
+                if (!blob) {
+                    return reject(new Error("Canvas toBlob failed"));
+                }
+                const compressedFile = new File([blob], file.name, {
+                    type: mimeType,
+                    lastModified: Date.now(),
+                });
+                resolve(compressedFile);
+            }, mimeType, quality);
+        };
+        img.onerror = (err) => {
+            URL.revokeObjectURL(img.src);
+            reject(err);
+        };
+    });
+}
+/**
+ * Checks if a file is an image that can be compressed.
+ */
+export function isCompressibleImage(file) {
+    return file.type.startsWith("image/") && !file.type.includes("svg") && !file.type.includes("gif");
+}

package/dist/lib/utils/imageUpload.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizeImageFile(file: File): Promise<File>;
+export declare function normalizeImageFiles(files: File[]): Promise<File[]>;
+export declare function prepareImageFiles(files: File[], maxImageSizeMb: number, onWarning: (message: string) => void | Promise<void>): Promise<File[]>;
+//# sourceMappingURL=imageUpload.d.ts.map

package/dist/lib/utils/imageUpload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageUpload.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/imageUpload.ts"],"names":[],"mappings":"AAAA,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAsBlE;AAED,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAExE;AAED,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,IAAI,EAAE,EACb,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACnD,OAAO,CAAC,IAAI,EAAE,CAAC,CAkBjB"}