ikoncomponents 1.5.5 → 1.5.7

package/dist/utils/api/softwareService/index.js

@@ -0,0 +1,212 @@
+import ikonBaseApi from "../ikonBaseApi";
+export const mapSoftwareName = async ({ softwareName, version, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "mapSoftwareName",
+        arguments_: [softwareName, version],
+    });
+    return result.data;
+};
+export const createSoftware = async ({ softwareName, softwareDescription, softwareVersion, softwareOwnerAccount, softwareDeveloperAccount, softwareManagerAccount, softwareAccessibility, softwareStatus, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "createSoftware",
+        arguments_: [
+            softwareName,
+            softwareDescription,
+            softwareVersion,
+            softwareOwnerAccount,
+            softwareDeveloperAccount,
+            softwareManagerAccount,
+            softwareAccessibility,
+            softwareStatus,
+        ],
+    });
+    return result.data;
+};
+export const editSoftware = async ({ softwareId, softwareName, softwareDescription, softwareVersion, softwareDeveloperAccount, softwareManagerAccount, softwareAccessibility, softwareStatus, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "editSoftware",
+        arguments_: [
+            softwareId,
+            softwareName,
+            softwareDescription,
+            softwareVersion,
+            softwareDeveloperAccount,
+            softwareManagerAccount,
+            softwareAccessibility,
+            softwareStatus,
+        ],
+    });
+    return result.data;
+};
+export const getAccessibleSoftwareForUser = async ({ accountId, userId, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "getAccessibleSoftwareForUser",
+        arguments_: [userId, accountId],
+    });
+    return result.data;
+};
+export const getAllSubscribedSoftwaresForClient = async ({ accountId }, isServerApi) => {
+    const result = await ikonBaseApi({
+        service: "softwareSubscriptionService",
+        operation: "getAllSubscribedSoftwaresForClient",
+        arguments_: [accountId],
+        isServerApi: isServerApi,
+    });
+    return result.data;
+};
+export const inviteAccountForSoftware = async ({ accountId, softwareId, expirationTime, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "inviteAccountForSoftware",
+        arguments_: [accountId, softwareId, expirationTime],
+    });
+    return result.data;
+};
+export const getAllSentSoftwareInviteRequests = async ({ accountId, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "getAllSentSoftwareInviteRequests",
+        arguments_: [accountId],
+    });
+    return result.data;
+};
+export const getAllReceivedSoftwareInviteRequests = async ({ accountId, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "getAllReceivedSoftwareInviteRequests",
+        arguments_: [accountId],
+    });
+    return result.data;
+};
+export const getAllSoftwareInvitesV2 = async ({ accountId, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "getAllSoftwareInvitesV2",
+        arguments_: [accountId],
+    });
+    return result.data;
+};
+export const acceptInvitationRequestForSoftware = async ({ requestId, shareKey, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "acceptInvitationRequestForSoftware",
+        arguments_: [requestId, shareKey],
+    });
+    return result.data;
+};
+export const cancelInvitationRequestForSoftware = async ({ requestId, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "cancelInvitationRequestForSoftware",
+        arguments_: [requestId],
+    });
+    return result.data;
+};
+export const rejectInvitationRequestForSoftware = async ({ requestId, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "rejectInvitationRequestForSoftware",
+        arguments_: [requestId],
+    });
+    return result.data;
+};
+export const activateSoftwareInviteForAccount = async ({ invitationId, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "activateSoftwareInviteForAccount",
+        arguments_: [invitationId],
+    });
+    return result.data;
+};
+export const deactivateSoftwareInviteForAccount = async ({ invitationId, }) => {
+    const result = await ikonBaseApi({
+        service: "accountInvitationService",
+        operation: "deactivateSoftwareInviteForAccount",
+        arguments_: [invitationId],
+    });
+    return result.data;
+};
+export const getAllPendingInvitationRequestsForUser = async ({ userId, }) => {
+    const result = await ikonBaseApi({
+        service: "userInvitationService",
+        operation: "getAllPendingInvitationRequestsForUser",
+        arguments_: [userId],
+    });
+    return result.data;
+};
+export const getAllInvitationRequestsSentByAccount = async ({ accountId, }) => {
+    const result = await ikonBaseApi({
+        service: "userInvitationService",
+        operation: "getAllInvitationRequestsSentByAccount",
+        arguments_: [accountId],
+    });
+    return result.data;
+};
+export const inviteUserToMyAccount = async ({ accountId, userLogin, }) => {
+    const result = await ikonBaseApi({
+        service: "userInvitationService",
+        operation: "inviteUserToMyAccount",
+        arguments_: [accountId, userLogin],
+    });
+    return result.data;
+};
+export const getMySoftwares = async ({ accountId }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "getMySoftwares",
+        arguments_: [accountId],
+    });
+    return result.data;
+};
+export const getMySoftwaresV2 = async ({ accountId, onlyActive = false, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "getMySoftwaresV2",
+        arguments_: [accountId, onlyActive],
+    });
+    return result.data;
+};
+export const getAvailableSoftwaresForAccount = async ({ accountId, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "getAvailableSoftwaresForAccount",
+        arguments_: [accountId],
+    });
+    return result.data;
+};
+export const getSoftwareById = async ({ softwareId, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "getSoftwareById",
+        arguments_: [softwareId],
+    });
+    return result.data;
+};
+export const activateSoftware = async ({ softwareId, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "activateSoftware",
+        arguments_: [softwareId],
+    });
+    return result.data;
+};
+export const deactivateSoftware = async ({ softwareId, }) => {
+    const result = await ikonBaseApi({
+        service: "softwareService",
+        operation: "deactivateSoftware",
+        arguments_: [softwareId],
+    });
+    return result.data;
+};
+export const requestForFinalSubscription = async ({ accountId, userId, softwareId, suggestedDate = null, }) => {
+    const result = await ikonBaseApi({
+        service: "requestService",
+        operation: "requestForFinalSubscription",
+        arguments_: [accountId, userId, softwareId, suggestedDate],
+    });
+    return result.data;
+};

package/dist/utils/api/softwareService/type.d.ts

@@ -0,0 +1,54 @@
+export interface mapSoftwareNameProps {
+    softwareName: string;
+    version: string;
+}
+export interface CreateSoftwareProps {
+    softwareName: string;
+    softwareDescription: string;
+    softwareVersion: number;
+    softwareOwnerAccount: string;
+    softwareDeveloperAccount: string;
+    softwareManagerAccount: string | null;
+    softwareAccessibility: string;
+    softwareStatus: string;
+}
+export interface EditSoftwareProps {
+    softwareId: string;
+    softwareName: string;
+    softwareDescription: string;
+    softwareVersion: number;
+    softwareDeveloperAccount: string;
+    softwareManagerAccount: string | null;
+    softwareAccessibility: string;
+    softwareStatus: string;
+}
+export interface getAllSubscribedSoftwaresForClientProps {
+    accountId?: string;
+}
+export interface getAccessibleSoftwareForUserProps {
+    accountId?: string;
+    userId: string;
+}
+export interface getMySoftwaresProps {
+    accountId?: string;
+}
+export interface getMySoftwaresV2Props {
+    accountId?: string;
+    onlyActive?: boolean;
+}
+export interface getAvailableSoftwaresForAccountProps {
+    accountId?: string;
+}
+export interface SubscribeSoftwareProps {
+    ACCOUNT_ID: string;
+    SOFTWARE_ID: string;
+    SOFTWARE_NAME: string;
+    SOFTWARE_VERSION: number;
+    SOFTWARE_DESCRIPTION: string;
+    SOFTWARE_OWNER_ID: string;
+    SOFTWARE_OWNER_NAME: string;
+    SOFTWARE_ACCESSIBILITY: "PUBLIC" | "PRIVATE";
+    ACTIVE: boolean;
+    PURCHASE_DATE: string;
+    EXPIRES_ON: string | null;
+}

package/dist/utils/api/softwareService/type.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/border-radius-provider.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+type RadiusValue = 0 | 0.25 | 0.5 | 0.75 | 1;
+interface RadiusContextType {
+    radius: RadiusValue;
+    setRadius: (radius: RadiusValue) => void;
+}
+export declare function RadiusProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const useRadius: () => RadiusContextType;
+export {};

package/{templates/default/utils/border-radius-provider.tsx → dist/utils/border-radius-provider.js}

@@ -1,59 +1,35 @@
-'use client';
-
-import React, {
-    createContext,
-    useContext,
-    useState,
-    useEffect,
-    useMemo
-} from 'react';
-
-type RadiusValue = 0 | 0.25 | 0.5 | 0.75 | 1;
-
-interface RadiusContextType {
-    radius: RadiusValue;
-    setRadius: (radius: RadiusValue) => void;
-}
-
-const RadiusContext = createContext<RadiusContextType | undefined>(undefined);
-
-export function RadiusProvider({ children }: { children: React.ReactNode }) {
-    const [radius, setRadius] = useState<RadiusValue>(0.5);
-    const [mounted, setMounted] = useState(false);
-
-    useEffect(() => {
-        setMounted(true);
-        const storedRadius = localStorage.getItem('app-radius');
-        if (storedRadius) {
-            const parsed = parseFloat(storedRadius) as RadiusValue;
-            if ([0, 0.25, 0.5, 0.75, 1].includes(parsed)) {
-                setRadius(parsed);
-            }
-        }
-    }, []);
-
-    useEffect(() => {
-        if (!mounted) return;
-
-        const radiusInRem = radius === 0 ? '0rem' : `${radius}rem`;
-        document.documentElement.style.setProperty('--radius', radiusInRem);
-        localStorage.setItem('app-radius', radius.toString());
-        console.log('Radius changed to:', radius, radiusInRem);
-    }, [radius, mounted]);
-
-    const value = useMemo(() => ({ radius, setRadius }), [radius]);
-
-    return (
-        <RadiusContext.Provider value={value}>
-            {children}
-        </RadiusContext.Provider>
-    );
-}
-
-export const useRadius = () => {
-    const context = useContext(RadiusContext);
-    if (context === undefined) {
-        throw new Error('useRadius must be used within a RadiusProvider');
-    }
-    return context;
-};
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useEffect, useMemo } from 'react';
+const RadiusContext = createContext(undefined);
+export function RadiusProvider({ children }) {
+    const [radius, setRadius] = useState(0.5);
+    const [mounted, setMounted] = useState(false);
+    useEffect(() => {
+        setMounted(true);
+        const storedRadius = localStorage.getItem('app-radius');
+        if (storedRadius) {
+            const parsed = parseFloat(storedRadius);
+            if ([0, 0.25, 0.5, 0.75, 1].includes(parsed)) {
+                setRadius(parsed);
+            }
+        }
+    }, []);
+    useEffect(() => {
+        if (!mounted)
+            return;
+        const radiusInRem = radius === 0 ? '0rem' : `${radius}rem`;
+        document.documentElement.style.setProperty('--radius', radiusInRem);
+        localStorage.setItem('app-radius', radius.toString());
+        console.log('Radius changed to:', radius, radiusInRem);
+    }, [radius, mounted]);
+    const value = useMemo(() => ({ radius, setRadius }), [radius]);
+    return (_jsx(RadiusContext.Provider, { value: value, children: children }));
+}
+export const useRadius = () => {
+    const context = useContext(RadiusContext);
+    if (context === undefined) {
+        throw new Error('useRadius must be used within a RadiusProvider');
+    }
+    return context;
+};

package/dist/utils/cn.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/utils/cn.js

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist/utils/font-provider.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+type FontName = 'Poppins' | 'Oswald' | 'Outfit';
+interface FontContextType {
+    font: FontName;
+    setFont: (font: FontName) => void;
+}
+export declare function FontProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const useFont: () => FontContextType;
+export {};

package/{templates/default/utils/font-provider.tsx → dist/utils/font-provider.js}

@@ -1,61 +1,37 @@
-'use client';
-
-import React, {
-    createContext,
-    useContext,
-    useState,
-    useEffect,
-    useMemo
-} from 'react';
-
-type FontName = 'Poppins' | 'Oswald' | 'Outfit';
-
-interface FontContextType {
-    font: FontName;
-    setFont: (font: FontName) => void;
-}
-
-const FontContext = createContext<FontContextType | undefined>(undefined);
-
-export function FontProvider({ children }: { children: React.ReactNode }) {
-    const [font, setFont] = useState<FontName>('Poppins');
-    const [mounted, setMounted] = useState(false);
-
-    useEffect(() => {
-        setMounted(true);
-        const storedFont = localStorage.getItem('app-font') as FontName;
-        if (storedFont && ['Poppins', 'Oswald', 'Outfit'].includes(storedFont)) {
-            setFont(storedFont);
-        }
-    }, []);
-
-    useEffect(() => {
-        if (!mounted) return;
-
-        const fontVariables: Record<FontName, string> = {
-            Poppins: 'var(--font-poppins)',
-            Oswald: 'var(--font-oswald)',
-            Outfit: 'var(--font-outfit)',
-        };
-        document.body.style.fontFamily = fontVariables[font];
-        document.documentElement.style.fontFamily = fontVariables[font];
-        localStorage.setItem('app-font', font);
-        console.log('Font changed to:', font, fontVariables[font]);
-    }, [font, mounted]);
-
-    const value = useMemo(() => ({ font, setFont }), [font]);
-
-    return (
-        <FontContext.Provider value={value}>
-            {children}
-        </FontContext.Provider>
-    );
-}
-
-export const useFont = () => {
-    const context = useContext(FontContext);
-    if (context === undefined) {
-        throw new Error('useFont must be used within a FontProvider');
-    }
-    return context;
-};
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useEffect, useMemo } from 'react';
+const FontContext = createContext(undefined);
+export function FontProvider({ children }) {
+    const [font, setFont] = useState('Poppins');
+    const [mounted, setMounted] = useState(false);
+    useEffect(() => {
+        setMounted(true);
+        const storedFont = localStorage.getItem('app-font');
+        if (storedFont && ['Poppins', 'Oswald', 'Outfit'].includes(storedFont)) {
+            setFont(storedFont);
+        }
+    }, []);
+    useEffect(() => {
+        if (!mounted)
+            return;
+        const fontVariables = {
+            Poppins: 'var(--font-poppins)',
+            Oswald: 'var(--font-oswald)',
+            Outfit: 'var(--font-outfit)',
+        };
+        document.body.style.fontFamily = fontVariables[font];
+        document.documentElement.style.fontFamily = fontVariables[font];
+        localStorage.setItem('app-font', font);
+        console.log('Font changed to:', font, fontVariables[font]);
+    }, [font, mounted]);
+    const value = useMemo(() => ({ font, setFont }), [font]);
+    return (_jsx(FontContext.Provider, { value: value, children: children }));
+}
+export const useFont = () => {
+    const context = useContext(FontContext);
+    if (context === undefined) {
+        throw new Error('useFont must be used within a FontProvider');
+    }
+    return context;
+};

package/dist/utils/session/cookieSession.d.ts

@@ -0,0 +1,8 @@
+export interface CookieSessionOptionsProps {
+    maxAge?: number;
+    expires?: Date;
+}
+export declare function setCookieSession(sessionName: string, data: string, options?: CookieSessionOptionsProps): Promise<void>;
+export declare function getCookieSession(sessionName: string): Promise<string | undefined>;
+export declare function clearCookieSession(sessionName: string): Promise<void>;
+export declare function clearAllCookieSession(): Promise<void>;

package/dist/utils/session/cookieSession.js

@@ -0,0 +1,33 @@
+"use server";
+import { cookies } from "next/headers";
+const cookiePrefix = "ikoncloud_next_";
+export async function setCookieSession(sessionName, data, options) {
+    const cookieStore = await cookies();
+    cookieStore.set(cookiePrefix + sessionName, data, {
+        httpOnly: true,
+        sameSite: "lax",
+        secure: process.env.NODE_ENV === "production",
+        path: "/",
+        domain: process.env.NEXT_PUBLIC_COOKIE_DOMAIN,
+        expires: options === null || options === void 0 ? void 0 : options.expires,
+        maxAge: options === null || options === void 0 ? void 0 : options.maxAge,
+    });
+}
+export async function getCookieSession(sessionName) {
+    var _a;
+    const cookieStore = await cookies();
+    const cookie = (_a = cookieStore.get(cookiePrefix + sessionName)) === null || _a === void 0 ? void 0 : _a.value;
+    return cookie;
+}
+export async function clearCookieSession(sessionName) {
+    const cookieStore = await cookies();
+    cookieStore.delete(cookiePrefix + sessionName);
+}
+export async function clearAllCookieSession() {
+    const cookieStore = await cookies();
+    cookieStore.getAll().forEach((cookie) => {
+        if (cookie.name.startsWith(cookiePrefix)) {
+            cookieStore.delete(cookie.name);
+        }
+    });
+}

package/dist/utils/theme-provider/index.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+import { ThemeProvider as NextThemesProvider } from "next-themes";
+export declare function ThemeProvider({ children, ...props }: React.ComponentProps<typeof NextThemesProvider>): import("react/jsx-runtime").JSX.Element;

package/dist/utils/theme-provider/index.js

@@ -0,0 +1,18 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ThemeProvider as NextThemesProvider } from "next-themes";
+export function ThemeProvider(_a) {
+    var { children } = _a, props = __rest(_a, ["children"]);
+    return _jsx(NextThemesProvider, Object.assign({}, props, { children: children }));
+}

package/dist/utils/token-management/index.d.ts

@@ -0,0 +1,10 @@
+interface AccessTokenOptionsProps {
+    isNotLogOutWhenExpire?: boolean;
+    platformUrl?: string;
+    isSetToken?: boolean;
+}
+export declare function getValidAccessToken(baseUrl: string, options?: AccessTokenOptionsProps): Promise<string | null>;
+export declare function refreshAccessToken(refreshToken: string, baseUrl: string, isSetToken?: boolean): Promise<string | null>;
+export declare function decodeAccessToken(baseUrl: string): Promise<import("jwt-decode").JwtPayload | null>;
+export declare function logOut(platformUrl: string): Promise<void>;
+export {};

package/dist/utils/token-management/index.js

@@ -0,0 +1,69 @@
+"use server";
+import { redirect } from "next/navigation";
+import { clearAllCookieSession, getCookieSession, setCookieSession, } from "../session/cookieSession";
+import { jwtDecode } from "jwt-decode";
+// Prevent multiple refresh calls at once
+let refreshPromise = null;
+export async function getValidAccessToken(baseUrl, options) {
+    const accessToken = await getCookieSession("accessToken");
+    console.log("Access Token....:");
+    const refreshToken = await getCookieSession("refreshToken");
+    console.log("Refresh Token...");
+    console.log("Before Return Access Token:...............................................");
+    if (accessToken)
+        return accessToken;
+    console.log("After Return Access Token:...............................................");
+    if (refreshToken) {
+        console.log("Refreshing access token using refresh token...", refreshToken);
+        if (!refreshPromise) {
+            refreshPromise = refreshAccessToken(refreshToken, baseUrl, options === null || options === void 0 ? void 0 : options.isSetToken);
+            refreshPromise.finally(() => (refreshPromise = null));
+        }
+        return await refreshPromise;
+    }
+    if (!(options === null || options === void 0 ? void 0 : options.isNotLogOutWhenExpire) && (options === null || options === void 0 ? void 0 : options.platformUrl)) {
+        await logOut(options === null || options === void 0 ? void 0 : options.platformUrl);
+    }
+    return null;
+}
+export async function refreshAccessToken(refreshToken, baseUrl, isSetToken) {
+    try {
+        console.log("Refreshing access token...");
+        const response = await fetch(`${baseUrl}/platform/auth/refresh-token`, {
+            method: "POST",
+            credentials: "include",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ refreshToken }),
+        });
+        console.log("Refresh Token API Response:", response.status);
+        if (!response.ok)
+            return null;
+        const { accessToken, refreshToken: newRefreshToken, expiresIn, refreshExpiresIn, } = await response.json();
+        //  Always set new access token
+        await setCookieSession("accessToken", accessToken, {
+            maxAge: expiresIn,
+        });
+        //  IMPORTANT: Save the rotated refresh token
+        if (newRefreshToken) {
+            await setCookieSession("refreshToken", newRefreshToken, {
+                maxAge: refreshExpiresIn,
+            });
+            console.log("Refresh token rotated & updated.");
+        }
+        console.log(" Access token refreshed successfully.");
+        return accessToken;
+    }
+    catch (error) {
+        console.error("Failed to refresh access token:", error);
+        return null;
+    }
+}
+export async function decodeAccessToken(baseUrl) {
+    const accessToken = await getValidAccessToken(baseUrl);
+    return accessToken ? jwtDecode(accessToken) : null;
+}
+export async function logOut(platformUrl) {
+    await clearAllCookieSession();
+    console.log("Logging out...");
+    redirect(`${platformUrl}/login.html`);
+}

package/dist/utils/token-management/types.d.ts

@@ -0,0 +1,6 @@
+export interface TokenResponse {
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    refreshExpiresIn: number;
+}

package/dist/utils/token-management/types.js

@@ -0,0 +1 @@
+export {};