ikoncomponents 1.2.0 → 1.2.2

package/dist/styles.css

@@ -8,6 +8,8 @@
     --color-blue-400: oklch(70.7% 0.165 254.624);
     --color-blue-500: oklch(62.3% 0.214 259.815);
     --color-blue-600: oklch(54.6% 0.245 262.881);
+    --color-slate-400: oklch(70.4% 0.04 256.788);
+    --color-gray-100: oklch(96.7% 0.003 264.542);
     --color-gray-300: oklch(87.2% 0.01 258.338);
     --color-gray-400: oklch(70.7% 0.022 261.325);
     --color-gray-500: oklch(55.1% 0.027 264.364);
@@ -28,6 +30,7 @@
     --container-md: 28rem;
     --container-lg: 32rem;
     --container-3xl: 48rem;
+    --container-5xl: 64rem;
     --text-xs: 0.75rem;
     --text-xs--line-height: calc(1 / 0.75);
     --text-sm: 0.875rem;
@@ -413,6 +416,9 @@
   .mb-2 {
     margin-bottom: calc(var(--spacing) * 2);
   }
+  .mb-3 {
+    margin-bottom: calc(var(--spacing) * 3);
+  }
   .mb-4 {
     margin-bottom: calc(var(--spacing) * 4);
   }
@@ -578,6 +584,15 @@
   .h-\[1\.15rem\] {
     height: 1.15rem;
   }
+  .h-\[120px\] {
+    height: 120px;
+  }
+  .h-\[200px\] {
+    height: 200px;
+  }
+  .h-\[220px\] {
+    height: 220px;
+  }
   .h-\[calc\(100\%-1px\)\] {
     height: calc(100% - 1px);
   }
@@ -620,6 +635,9 @@
   .max-h-\[400px\] {
     max-height: 400px;
   }
+  .max-h-full {
+    max-height: 100%;
+  }
   .min-h-0 {
     min-height: calc(var(--spacing) * 0);
   }
@@ -647,24 +665,42 @@
   .w-0\.5 {
     width: calc(var(--spacing) * 0.5);
   }
+  .w-1\/2 {
+    width: calc(1/2 * 100%);
+  }
+  .w-1\/3 {
+    width: calc(1/3 * 100%);
+  }
   .w-2 {
     width: calc(var(--spacing) * 2);
   }
   .w-2\.5 {
     width: calc(var(--spacing) * 2.5);
   }
+  .w-2\/5 {
+    width: calc(2/5 * 100%);
+  }
   .w-3 {
     width: calc(var(--spacing) * 3);
   }
   .w-3\/4 {
     width: calc(3/4 * 100%);
   }
+  .w-3\/5 {
+    width: calc(3/5 * 100%);
+  }
   .w-4 {
     width: calc(var(--spacing) * 4);
   }
+  .w-4\/5 {
+    width: calc(4/5 * 100%);
+  }
   .w-5 {
     width: calc(var(--spacing) * 5);
   }
+  .w-5\/5 {
+    width: calc(5/5 * 100%);
+  }
   .w-6 {
     width: calc(var(--spacing) * 6);
   }
@@ -949,6 +985,9 @@
   .flex-row {
     flex-direction: row;
   }
+  .flex-row-reverse {
+    flex-direction: row-reverse;
+  }
   .flex-wrap {
     flex-wrap: wrap;
   }
@@ -1038,6 +1077,9 @@
   .gap-y-0\.5 {
     row-gap: calc(var(--spacing) * 0.5);
   }
+  .self-end {
+    align-self: flex-end;
+  }
   .self-start {
     align-self: flex-start;
   }
@@ -1140,6 +1182,10 @@
     border-style: var(--tw-border-style) !important;
     border-width: 2px !important;
   }
+  .border-x-0 {
+    border-inline-style: var(--tw-border-style);
+    border-inline-width: 0px;
+  }
   .border-y {
     border-block-style: var(--tw-border-style);
     border-block-width: 1px;
@@ -1148,6 +1194,10 @@
     border-inline-start-style: var(--tw-border-style);
     border-inline-start-width: 0px;
   }
+  .border-e-0 {
+    border-inline-end-style: var(--tw-border-style);
+    border-inline-end-width: 0px;
+  }
   .border-t {
     border-top-style: var(--tw-border-style);
     border-top-width: 1px;
@@ -1195,6 +1245,9 @@
   .border-border {
     border-color: var(--border);
   }
+  .border-gray-400 {
+    border-color: var(--color-gray-400);
+  }
   .border-input {
     border-color: var(--input);
   }
@@ -1300,6 +1353,9 @@
   .bg-foreground {
     background-color: var(--foreground);
   }
+  .bg-gray-100 {
+    background-color: var(--color-gray-100);
+  }
   .bg-gray-300 {
     background-color: var(--color-gray-300);
   }
@@ -1333,6 +1389,9 @@
   .bg-sidebar-border {
     background-color: var(--sidebar-border);
   }
+  .bg-slate-400 {
+    background-color: var(--color-slate-400);
+  }
   .bg-transparent {
     background-color: transparent;
   }
@@ -1459,6 +1518,12 @@
   .pr-8 {
     padding-right: calc(var(--spacing) * 8);
   }
+  .pr-10 {
+    padding-right: calc(var(--spacing) * 10);
+  }
+  .pb-1 {
+    padding-bottom: calc(var(--spacing) * 1);
+  }
   .pb-2 {
     padding-bottom: calc(var(--spacing) * 2);
   }
@@ -1624,6 +1689,9 @@
   .text-gray-600 {
     color: var(--color-gray-600);
   }
+  .text-gray-700 {
+    color: var(--color-gray-700);
+  }
   .text-input {
     color: var(--input);
   }
@@ -2509,6 +2577,13 @@
       }
     }
   }
+  .hover\:bg-transparent\! {
+    &:hover {
+      @media (hover: hover) {
+        background-color: transparent !important;
+      }
+    }
+  }
   .hover\:text-accent-foreground {
     &:hover {
       @media (hover: hover) {
@@ -3942,6 +4017,26 @@
       display: none;
     }
   }
+  .lg\:w-48 {
+    @media (width >= 64rem) {
+      width: calc(var(--spacing) * 48);
+    }
+  }
+  .lg\:max-w-5xl {
+    @media (width >= 64rem) {
+      max-width: var(--container-5xl);
+    }
+  }
+  .lg\:flex-col {
+    @media (width >= 64rem) {
+      flex-direction: column;
+    }
+  }
+  .lg\:flex-row {
+    @media (width >= 64rem) {
+      flex-direction: row;
+    }
+  }
   .lg\:justify-start {
     @media (width >= 64rem) {
       justify-content: flex-start;

package/dist/utils/actions/account/index.d.ts

@@ -0,0 +1,5 @@
+import { AccountTreeProps } from "./type";
+export declare const getAccount: () => Promise<AccountTreeProps>;
+export declare const getActiveAccountId: () => Promise<string>;
+export declare const getOrSetActiveAccountId: () => Promise<string>;
+export declare const setActiveAccountId: (accountId: string) => Promise<void>;

package/dist/utils/actions/account/index.js

@@ -0,0 +1,28 @@
+"use server";
+import { cache } from "react";
+import { getAccountTree } from "../../api/accountService";
+import { getCookieSession, setCookieSession } from "../../session/cookieSession";
+export const getAccount = cache(async () => {
+    return await getAccountTree();
+});
+export const getActiveAccountId = async () => {
+    const activeAccountId = await getCookieSession("activeAccountId");
+    return activeAccountId || "";
+};
+export const getOrSetActiveAccountId = async () => {
+    let activeAccountId = await getCookieSession("activeAccountId");
+    if (!activeAccountId) {
+        try {
+            const account = await getAccount();
+            activeAccountId = account.ACCOUNT_ID;
+            await setActiveAccountId(activeAccountId);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    return activeAccountId || "";
+};
+export const setActiveAccountId = async (accountId) => {
+    await setCookieSession("activeAccountId", accountId);
+};

package/dist/utils/actions/account/type.d.ts

@@ -0,0 +1,4 @@
+export interface AccountTreeProps {
+    ACCOUNT_ID: string;
+    ACCOUNT_NAME: string;
+}

package/dist/utils/actions/account/type.js

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

package/dist/utils/actions/auth/index.d.ts

@@ -0,0 +1,7 @@
+import { GetLoggedInUserProfileDetailsReturnProps, GetLoggedInUserProfileReturnProps } from "../../api/loginService/type";
+export declare const setTicket: (ticket: string) => Promise<void>;
+export declare const getTicket: () => Promise<string | undefined>;
+export declare const getProfileData: () => Promise<GetLoggedInUserProfileReturnProps & GetLoggedInUserProfileDetailsReturnProps>;
+export declare function signOut(): Promise<void>;
+export declare const getCurrentUserId: () => Promise<string>;
+export declare const setCurrentUserId: (userId: string) => Promise<void>;

package/dist/utils/actions/auth/index.js

@@ -0,0 +1,58 @@
+"use server";
+import { redirect } from "next/navigation";
+import { logout } from "../../api/loginService";
+import { clearAllCookieSession, getCookieSession, setCookieSession } from "../../session/cookieSession";
+import { cookies } from "next/headers";
+export const setTicket = async (ticket) => {
+    await setCookieSession("ticket", ticket);
+};
+export const getTicket = async () => {
+    return await getCookieSession("ticket");
+};
+export const getProfileData = async () => {
+    const cookieStore = await cookies();
+    const cookieHeader = cookieStore.getAll()
+        .map(({ name, value }) => `${name}=${value}`)
+        .join("; "); // Convert to a valid Cookie header string
+    // Fetch API with cookies
+    const resp = await fetch(`${process.env.NEXT_BASE_PATH_URL}/api/profile`, {
+        method: "GET",
+        headers: {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Cookie": cookieHeader, // ✅ Send all cookies
+        },
+        cache: "force-cache",
+    });
+    return resp.json();
+    // let data1: GetLoggedInUserProfileReturnProps = {} as GetLoggedInUserProfileReturnProps;
+    // try {
+    //     data1 = await getLoggedInUserProfile();
+    // } catch (error) {
+    //     console.error(error)
+    // }
+    // let data2: GetLoggedInUserProfileDetailsReturnProps = {} as GetLoggedInUserProfileDetailsReturnProps;
+    // try {
+    //     data2 = await getLoggedInUserProfileDetails();
+    // } catch (error) {
+    //     console.error(error)
+    // }
+    // return { ...data1, ...data2 };
+};
+export async function signOut() {
+    try {
+        await logout();
+    }
+    catch (error) {
+        console.error(error);
+    }
+    await clearAllCookieSession();
+    redirect("/login");
+}
+export const getCurrentUserId = async () => {
+    const currentUserId = await getCookieSession("currentUserId");
+    return currentUserId || "";
+};
+export const setCurrentUserId = async (userId) => {
+    await setCookieSession("currentUserId", userId);
+};

package/dist/utils/actions/common/utils.d.ts

@@ -0,0 +1,5 @@
+import { FileinfoProps } from "../../api/file-upload/type";
+export declare function getSrcFromBase64String(imgString?: string | null, type?: string): string;
+export declare function getResourceUrl(fileInfo: FileinfoProps): Promise<string>;
+export declare function downloadResource(fileInfo: FileinfoProps): Promise<void>;
+export declare function openFileInNewTab(url: string): Promise<void>;

package/dist/utils/actions/common/utils.js

@@ -0,0 +1,25 @@
+import { getTicket } from "../auth";
+export function getSrcFromBase64String(imgString, type) {
+    return imgString ? `data:${type || "image/webp"};base64,${imgString}` : "";
+}
+export async function getResourceUrl(fileInfo) {
+    const globalTicket = await getTicket();
+    return "https://ikoncloud-dev.keross.com/ikon-api/download" + "?ticket=" + globalTicket + "&resourceId=" + fileInfo.resourceId + "&resourceName=" + fileInfo.resourceName + "&resourceType=" + fileInfo.resourceType;
+}
+export async function downloadResource(fileInfo) {
+    const resourceUrl = await getResourceUrl(fileInfo);
+    window.open(encodeURI(resourceUrl));
+}
+export async function openFileInNewTab(url) {
+    const encodedLink = encodeURI(url);
+    try {
+        const response = await fetch(encodedLink);
+        const blob = await response.blob();
+        const blobUrl = URL.createObjectURL(blob);
+        window.open(blobUrl, '_blank');
+    }
+    catch (err) {
+        console.error('Failed to open file in new tab:', err);
+    }
+}
+;

package/dist/utils/actions/software/index.d.ts

@@ -0,0 +1,11 @@
+import { SubscribeSoftwareProps } from "../../api/softwareService/type";
+export declare const getBaseSoftwareId: () => Promise<string | undefined>;
+export declare const getOrSetBaseSoftwareId: () => Promise<string | undefined>;
+export declare const setBaseSoftwareId: (softwareId: string) => Promise<void>;
+export declare const getCurrentSoftwareId: () => Promise<string>;
+export declare const getCurrentAppName: () => Promise<string>;
+export declare const setCurrentSoftwareId: (softwareId: string) => Promise<void>;
+export declare const getSoftwareIdByNameVersion: (softwareName: string, version: string) => Promise<string>;
+export declare const setCurrentSoftwareIdByNameVersion: (softwareName: string, version: string) => Promise<void>;
+export declare const getAccessibleSoftware: (accountId: string, userId: string) => Promise<any>;
+export declare const getAllSubscribedSoftwares: (accountId?: string) => Promise<SubscribeSoftwareProps[]>;

package/dist/utils/actions/software/index.js

@@ -0,0 +1,75 @@
+"use server";
+import { cache } from "react";
+import { getAccessibleSoftwareForUser, mapSoftwareName, } from "../../api/softwareService";
+import { getCookieSession, setCookieSession, } from "../../session/cookieSession";
+import { cookies } from "next/headers";
+export const getBaseSoftwareId = async () => {
+    return await getCookieSession("baseSoftwareId");
+};
+export const getOrSetBaseSoftwareId = async () => {
+    let baseSoftwareId = await getCookieSession("baseSoftwareId");
+    if (!baseSoftwareId) {
+        try {
+            baseSoftwareId = await getSoftwareIdByNameVersion("Base App", "1");
+            await setBaseSoftwareId(baseSoftwareId);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    return baseSoftwareId;
+};
+export const setBaseSoftwareId = async (softwareId) => {
+    await setCookieSession("baseSoftwareId", softwareId);
+};
+export const getCurrentSoftwareId = async () => {
+    return (await getCookieSession("currentSoftwareId")) || "";
+};
+export const getCurrentAppName = async () => {
+    return (await getCookieSession("currentAppName")) || "";
+};
+export const setCurrentSoftwareId = async (softwareId) => {
+    await setCookieSession("currentSoftwareId", softwareId);
+};
+export const getSoftwareIdByNameVersion = cache(async (softwareName, version) => {
+    return await mapSoftwareName({ softwareName, version });
+});
+export const setCurrentSoftwareIdByNameVersion = async (softwareName, version) => {
+    const softwareId = await getSoftwareIdByNameVersion(softwareName, version);
+    await setCurrentSoftwareId(softwareId);
+};
+export const getAccessibleSoftware = cache(async (accountId, userId) => {
+    return await getAccessibleSoftwareForUser({ accountId, userId });
+});
+// export const getAllSubscribedSoftwares = cache(async (accountId: string) => {
+//     return await getAllSubscribedSoftwaresForClient({ accountId });
+// });
+export const getAllSubscribedSoftwares = async (accountId) => {
+    try {
+        const cookieStore = await cookies();
+        const cookieHeader = cookieStore
+            .getAll()
+            .map(({ name, value }) => `${name}=${value}`)
+            .join("; "); // Convert to a valid Cookie header string
+        // Fetch API with cookies
+        const resp = await fetch(`${process.env.NEXT_BASE_PATH_URL}/api/software/subscribe`, {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json",
+                Cookie: cookieHeader, // ✅ Send all cookies
+                body: JSON.stringify({
+                    accountId,
+                }),
+            },
+            cache: "force-cache",
+        });
+        if (!resp.ok)
+            throw new Error("Failed to fetch subscribe softwares");
+        return resp.json();
+    }
+    catch (error) {
+        console.error(error);
+        return [];
+    }
+};

package/dist/utils/api/accountService/index.d.ts

@@ -0,0 +1,23 @@
+import { GetAccountTreeProps } from "./type";
+export declare const getAccountTree: () => Promise<GetAccountTreeProps>;
+export declare const checkExistingAccount: ({ accountName, }: {
+    accountName: string;
+}) => Promise<boolean>;
+export declare const getFullAccountTree: () => Promise<any>;
+export declare const getAllInvitedAccountsForUser: (userId: string) => Promise<any>;
+export declare const acceptAccountInvitationRequest: ({ userId, requestId, }: {
+    userId: string;
+    requestId: string;
+}) => Promise<any>;
+export declare const rejectAccountInvitationRequest: ({ userId, requestId, }: {
+    userId: string;
+    requestId: string;
+}) => Promise<any>;
+export declare const cancelAccountInvitationRequest: ({ userId, requestId, }: {
+    userId: string;
+    requestId: string;
+}) => Promise<any>;
+export declare const deactivateInvitedUserFromAccount: ({ userId, invitationId, }: {
+    userId: string;
+    invitationId: string;
+}) => Promise<any>;

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

@@ -0,0 +1,64 @@
+"use server";
+import ikonBaseApi from "../ikonBaseApi";
+export const getAccountTree = async () => {
+    const result = await ikonBaseApi({
+        service: "accountService",
+        operation: "getAccountTree",
+    });
+    return result.data;
+};
+export const checkExistingAccount = async ({ accountName, }) => {
+    const result = await ikonBaseApi({
+        service: "accountService",
+        operation: "checkExistingAccount",
+        arguments_: [accountName],
+    });
+    return result.data;
+};
+export const getFullAccountTree = async () => {
+    const result = await ikonBaseApi({
+        service: "accountService",
+        operation: "getFullAccountTree",
+    });
+    return result.data;
+};
+export const getAllInvitedAccountsForUser = async (userId) => {
+    const result = await ikonBaseApi({
+        service: "userInvitationService",
+        operation: "getAllInvitedAccountsForUser",
+        arguments_: [userId],
+    });
+    return result.data;
+};
+export const acceptAccountInvitationRequest = async ({ userId, requestId, }) => {
+    const result = await ikonBaseApi({
+        service: "userInvitationService",
+        operation: "acceptAccountInvitationRequest",
+        arguments_: [userId, requestId],
+    });
+    return result.data;
+};
+export const rejectAccountInvitationRequest = async ({ userId, requestId, }) => {
+    const result = await ikonBaseApi({
+        service: "userInvitationService",
+        operation: "rejectAccountInvitationRequest",
+        arguments_: [userId, requestId],
+    });
+    return result.data;
+};
+export const cancelAccountInvitationRequest = async ({ userId, requestId, }) => {
+    const result = await ikonBaseApi({
+        service: "userInvitationService",
+        operation: "cancelAccountInvitationRequest",
+        arguments_: [userId, requestId],
+    });
+    return result.data;
+};
+export const deactivateInvitedUserFromAccount = async ({ userId, invitationId, }) => {
+    const result = await ikonBaseApi({
+        service: "userInvitationService",
+        operation: "deactivateInvitedUserFromAccount",
+        arguments_: [userId, invitationId],
+    });
+    return result.data;
+};

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

@@ -0,0 +1,4 @@
+export interface GetAccountTreeProps {
+    ACCOUNT_ID: string;
+    ACCOUNT_NAME: string;
+}

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

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

package/dist/utils/api/file-upload/index.d.ts

@@ -0,0 +1,5 @@
+import { FileinfoProps } from "./type";
+export declare function singleFileUpload(file: File, resourceId?: string): Promise<FileinfoProps>;
+export declare function multipleFileUpload(files: File[], resourceId?: string): Promise<FileinfoProps[]>;
+export declare function base64FileUpload(base64File: string, resourceName: string, resourceType: string, resourceId?: string): Promise<FileinfoProps>;
+export declare function singleUAResourceUpload(file: File, folder: string): Promise<any>;

package/dist/utils/api/file-upload/index.js

@@ -0,0 +1,80 @@
+"use server";
+import { axiosInstance } from "../ikonBaseApi";
+import { v4 } from "uuid";
+import { getTicket } from "../../actions/auth";
+export async function singleFileUpload(file, resourceId) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const fileInfo = {};
+    fileInfo["resourceId"] = resourceId || v4();
+    fileInfo["resourceName"] = file.name;
+    fileInfo["resourceSize"] = file.size;
+    fileInfo["resourceType"] = file.type;
+    const globalTicket = (await getTicket()) || "";
+    const queryParams = new URLSearchParams({
+        ticket: globalTicket,
+        resourceId: fileInfo["resourceId"],
+    });
+    try {
+        const result = await axiosInstance({
+            method: "POST",
+            url: `https://ikoncloud-dev.keross.com/ikon-api/upload?${queryParams.toString()}`,
+            data: formData,
+            responseType: "json",
+            headers: { "Content-Type": "multipart/form-data" },
+        });
+        console.log("File upload result:", result);
+    }
+    catch (error) {
+        throw error;
+    }
+    return fileInfo;
+}
+export async function multipleFileUpload(files, resourceId) {
+    const fileInfos = [];
+    for (const file of files) {
+        const fileInfo = await singleFileUpload(file, resourceId);
+        fileInfos.push(fileInfo);
+    }
+    return fileInfos;
+}
+export async function base64FileUpload(base64File, resourceName, resourceType, resourceId) {
+    const base64 = base64File.split(",")[1];
+    const byteCharacters = atob(base64);
+    const byteNumbers = new Array(byteCharacters.length);
+    for (let i = 0; i < byteCharacters.length; i++) {
+        byteNumbers[i] = byteCharacters.charCodeAt(i);
+    }
+    const byteArray = new Uint8Array(byteNumbers);
+    const blob = new Blob([byteArray], { type: resourceType });
+    const file = new File([blob], resourceName, { type: resourceType });
+    return await singleFileUpload(file, resourceId);
+}
+export async function singleUAResourceUpload(file, folder) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const fileInfo = {};
+    fileInfo["folder"] = folder || "ikon";
+    fileInfo["resourceName"] = file.name;
+    fileInfo["resourceSize"] = file.size;
+    fileInfo["resourceType"] = file.type;
+    const globalTicket = (await getTicket()) || "";
+    const queryParams = new URLSearchParams({
+        ticket: globalTicket,
+        folder: fileInfo["folder"],
+    });
+    try {
+        const result = await axiosInstance({
+            method: "POST",
+            url: `https://ikoncloud-dev.keross.com/ikon-api//uaresourceupload?${queryParams.toString()}`,
+            data: formData,
+            responseType: "json",
+            headers: { "Content-Type": "multipart/form-data" },
+        });
+        console.log("File upload result:", result);
+    }
+    catch (error) {
+        throw error;
+    }
+    return fileInfo;
+}

package/dist/utils/api/file-upload/type.d.ts

@@ -0,0 +1,6 @@
+export interface FileinfoProps {
+    resourceId: string;
+    resourceName?: string;
+    resourceSize?: number;
+    resourceType?: string;
+}

package/dist/utils/api/file-upload/type.js

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

package/dist/utils/api/ikonBaseApi.d.ts

@@ -0,0 +1,12 @@
+interface IkonBaseApiProps {
+    service: string;
+    operation: string;
+    arguments_?: any | null;
+    accountId?: string | null;
+    softwareId?: string | null;
+    isTicketRequried?: boolean;
+    isServerApi?: boolean;
+}
+export declare const axiosInstance: import("axios").AxiosInstance;
+declare function ikonBaseApi({ service, operation, arguments_, accountId, softwareId, isTicketRequried, isServerApi }: IkonBaseApiProps): Promise<any>;
+export default ikonBaseApi;