@anji-dashing/dam-solution-v2 5.8.173

package/README.md

@@ -0,0 +1,53 @@
+# @bindu-dashing/dam-solution-v2
+
+---
+
+## Installation
+
+To install the library in your project:
+
+```bash
+npm install @bindu-dashing/dam-solution-v2
+# or
+yarn add @bindu-dashing/dam-solution-v2
+
+```
+
+## Local Testing
+
+To test the library in local before publishing it to npm:
+
+In Library
+
+```bash
+npm run build
+npm link
+```
+
+In test project:
+
+```bash
+npm link @bindu-dashing/dam-solution-v2
+```
+
+## Publishing
+
+To publish the library to npm:
+
+1. Update the version in package.json
+2. Next Steps
+
+```bash
+npm run build
+npm publish --access public
+
+```
+
+## Login
+
+To login to npm account:
+Before publishing, login to npm account if not already loggedin
+
+```bash
+npm login
+```

package/build/AssetType/AddFieldProperties.d.ts

@@ -0,0 +1,10 @@
+import { InputTypeEntity } from "../utilities/constants/interface";
+export default function AddFieldProperties({ field, setCurrentFieldIndex, onUpdateField, currentInputType, index, allFields, onCancel, }: {
+    field: InputTypeEntity | undefined;
+    setCurrentFieldIndex: (value: number | null) => void;
+    onUpdateField: (updatedValues: any, field: InputTypeEntity, index: number | null) => void;
+    currentInputType: InputTypeEntity | undefined;
+    index: number | null;
+    allFields: InputTypeEntity[];
+    onCancel?: (index: number | null) => void;
+}): JSX.Element;

package/build/AssetType/AddFieldProperties.js

@@ -0,0 +1,359 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Checkbox, Form, Input } from "antd";
+import TextField from "./fieldProperties/TextField";
+import NumberField from "./fieldProperties/NumberField";
+import { useEffect, useState } from "react";
+import DateField from "./fieldProperties/DateField";
+import OptionsField from "./fieldProperties/OptionsField";
+import { InputSupportedTypes, InputTypes, NotificationStatus, } from "../utilities/constants/interface";
+import { first, get, includes, isArray, nth } from "lodash";
+import { useDamConfig } from "../hocs/DamConfigContext";
+import useAppNavigate from "../utilities/useAppNavigate";
+import { getFormItem } from "../MyDrive/fileDetails/MetaForm";
+import dayjs from "dayjs";
+import { DATE_FORMAT, DATE_WITH_TIME_FORMAT } from "../hocs/appConstants";
+import { showNotification } from "../common/notifications";
+import { UPDATE_SUCCESS } from "../utilities/constants/messages";
+export default function AddFieldProperties({ field, setCurrentFieldIndex, onUpdateField, currentInputType, index, allFields, onCancel, }) {
+    const { styles } = useDamConfig();
+    const navigate = useAppNavigate();
+    const [defaultValueInput, setDefaultValueInput] = useState("");
+    const [loading, setLoading] = useState(false);
+    const [form] = Form.useForm();
+    const formValues = Form.useWatch([], form);
+    const [isFormValid, setIsFormValid] = useState(false);
+    const [disabledReason, setDisabledReason] = useState(null);
+    useEffect(() => {
+        const checkFormValidity = () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                // Only check errors for main fields (name, placeholder, defaultValue)
+                const mainFieldNames = ["name", "placeholder", "defaultValue"];
+                const errors = form.getFieldsError(mainFieldNames);
+                const hasMainFieldErrors = errors.some((error) => { var _a; return ((_a = error.errors) === null || _a === void 0 ? void 0 : _a.length) > 0; });
+                // Get current form values
+                const values = form.getFieldsValue();
+                const nameFilled = !!(values.name && typeof values.name === 'string' && values.name.trim() !== '');
+                const placeholderFilled = !!(values.placeholder && typeof values.placeholder === 'string' && values.placeholder.trim() !== '');
+                const valid = nameFilled && placeholderFilled && !hasMainFieldErrors;
+                setIsFormValid(valid);
+                // Set reason for disabled state so user knows why
+                if (!valid) {
+                    if (!nameFilled) {
+                        setDisabledReason("Name is required");
+                    }
+                    else if (!placeholderFilled) {
+                        setDisabledReason("Placeholder is required");
+                    }
+                    else if (hasMainFieldErrors) {
+                        const firstError = errors.find((e) => { var _a; return ((_a = e.errors) === null || _a === void 0 ? void 0 : _a.length) > 0; });
+                        const errorMsg = (_a = firstError === null || firstError === void 0 ? void 0 : firstError.errors) === null || _a === void 0 ? void 0 : _a[0];
+                        setDisabledReason(errorMsg ? `Fix error: ${errorMsg}` : "Please fix the form errors above");
+                    }
+                    else {
+                        setDisabledReason(null);
+                    }
+                }
+                else {
+                    setDisabledReason(null);
+                }
+            }
+            catch (error) {
+                setIsFormValid(false);
+                setDisabledReason("Unable to validate form");
+            }
+        });
+        checkFormValidity();
+    }, [formValues, form]);
+    const onUpdate = (values) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            setLoading(true);
+            const allValues = Object.assign({}, values);
+            // Format defaultValue if it exists (including empty string/null/undefined)
+            if (allValues.hasOwnProperty("defaultValue")) {
+                const formattedValue = getFormattedDefaultValue(allValues);
+                // Set to undefined if empty/null, otherwise use formatted value
+                allValues["defaultValue"] = formattedValue === null || formattedValue === "" ? undefined : formattedValue;
+            }
+            if (get(field, "_id", null)) {
+                allValues["_id"] = get(field, "_id");
+            }
+            // Small delay to show loading state
+            yield new Promise((resolve) => setTimeout(resolve, 300));
+            onUpdateField(allValues, currentInputType, index);
+            setCurrentFieldIndex(null);
+            showNotification(UPDATE_SUCCESS, NotificationStatus.SUCCESS);
+        }
+        catch (error) {
+            // Handle error if needed
+        }
+        finally {
+            setLoading(false);
+        }
+    });
+    const getFormattedDefaultValue = (values) => {
+        const defaultName = get(field, "defaultName");
+        const defaultValue = get(values, "defaultValue");
+        // console.log("default", defaultValue);
+        const allowTime = get(values, `inputTypeSettings.${InputSupportedTypes.ALLOW_TIME}.allow`, false);
+        const allowMultiple = get(values, `inputTypeSettings.${InputSupportedTypes.ALLOW_MULTIPLE}`, false);
+        switch (defaultName) {
+            case InputTypes.DATE_RANGE:
+            case InputTypes.DATE:
+                const format = allowTime ? DATE_WITH_TIME_FORMAT : DATE_FORMAT;
+                if (isArray(defaultValue) && get(defaultValue, "length") === 2) {
+                    return [
+                        first(defaultValue)
+                            ? dayjs(first(defaultValue)).format(format)
+                            : null,
+                        nth(defaultValue, 1)
+                            ? dayjs(nth(defaultValue, 1)).format(format)
+                            : null,
+                    ];
+                }
+                return defaultValue ? dayjs(defaultValue).format(format) : null;
+            case InputTypes.CHECKBOX:
+                return defaultValue || [];
+            case InputTypes.SELECT:
+                return allowMultiple ? defaultValue || [] : defaultValue || undefined;
+            case InputTypes.NUMBERS:
+                // Ensure defaultValue is a valid number, convert string to number if needed
+                if (defaultValue === null || defaultValue === undefined || defaultValue === "") {
+                    return undefined;
+                }
+                if (typeof defaultValue === "number" && !isNaN(defaultValue) && isFinite(defaultValue)) {
+                    return defaultValue;
+                }
+                if (typeof defaultValue === "string") {
+                    const parsed = Number(defaultValue);
+                    const trimmedValue = defaultValue.trim();
+                    if (!isNaN(parsed) && isFinite(parsed) && trimmedValue !== "") {
+                        return parsed;
+                    }
+                }
+                // If value is not a valid number, return undefined
+                return undefined;
+            default:
+                return defaultValue;
+        }
+    };
+    const getInitialDefaultValue = (inputTypeSettings) => {
+        const defaultName = currentInputType === null || currentInputType === void 0 ? void 0 : currentInputType.defaultName;
+        const allowMultiple = get(inputTypeSettings, `${InputSupportedTypes.ALLOW_MULTIPLE}`, false);
+        const value = get(field, "defaultValue", "");
+        switch (defaultName) {
+            case InputTypes.DATE:
+                return value ? dayjs(value) : undefined;
+            case InputTypes.DATE_RANGE:
+                return isArray(value) && get(value, "length") === 2
+                    ? [dayjs(first(value)), dayjs(nth(value, 1))]
+                    : undefined;
+            case InputTypes.SELECT:
+                return allowMultiple ? value || [] : value !== null && value !== void 0 ? value : undefined;
+            case InputTypes.CHECKBOX:
+                return value || [];
+            case InputTypes.NUMBERS:
+                // Convert string to number if valid, otherwise return undefined
+                if (value === null || value === undefined || value === "") {
+                    return undefined;
+                }
+                const valueType = typeof value;
+                if (valueType === "number" && !isNaN(value) && isFinite(value)) {
+                    return value;
+                }
+                if (valueType === "string") {
+                    const stringVal = value;
+                    const parsed = Number(stringVal);
+                    const trimmedValue = stringVal.trim();
+                    if (!isNaN(parsed) && isFinite(parsed) && trimmedValue !== "") {
+                        return parsed;
+                    }
+                }
+                // If value is not a valid number, return undefined
+                return undefined;
+            default:
+                return value;
+        }
+    };
+    useEffect(() => {
+        form.setFieldsValue(Object.assign(Object.assign({}, field), { defaultValue: getInitialDefaultValue(get(field, "inputTypeSettings", {})) }));
+        handleFormValuesChange();
+        // Check initial form validity after setting field values
+        setTimeout(() => {
+            var _a;
+            const mainFieldNames = ["name", "placeholder", "defaultValue"];
+            const errors = form.getFieldsError(mainFieldNames);
+            const hasMainFieldErrors = errors.some((error) => error.errors && error.errors.length > 0);
+            const values = form.getFieldsValue();
+            const nameFilled = !!(values.name && typeof values.name === 'string' && values.name.trim() !== '');
+            const placeholderFilled = !!(values.placeholder && typeof values.placeholder === 'string' && values.placeholder.trim() !== '');
+            const valid = nameFilled && placeholderFilled && !hasMainFieldErrors;
+            setIsFormValid(valid);
+            if (!valid) {
+                if (!nameFilled)
+                    setDisabledReason("Name is required");
+                else if (!placeholderFilled)
+                    setDisabledReason("Placeholder is required");
+                else if (hasMainFieldErrors) {
+                    const firstError = errors.find((e) => { var _a; return ((_a = e.errors) === null || _a === void 0 ? void 0 : _a.length) > 0; });
+                    setDisabledReason(((_a = firstError === null || firstError === void 0 ? void 0 : firstError.errors) === null || _a === void 0 ? void 0 : _a[0]) ? `Fix error: ${firstError.errors[0]}` : "Please fix the form errors above");
+                }
+                else
+                    setDisabledReason(null);
+            }
+            else
+                setDisabledReason(null);
+        }, 100);
+    }, [field, form]);
+    // Update defaultValueInput whenever form values change
+    const handleFormValuesChange = () => {
+        var _a;
+        const formValues = form.getFieldsValue(true);
+        const defaultName = currentInputType === null || currentInputType === void 0 ? void 0 : currentInputType.defaultName;
+        const options = ((_a = formValues.options) === null || _a === void 0 ? void 0 : _a.filter((opt) => (opt === null || opt === void 0 ? void 0 : opt.label) && (opt === null || opt === void 0 ? void 0 : opt.value))) || [];
+        const settings = formValues.inputTypeSettings || {};
+        const isOptionsBasedField = includes([InputTypes.SELECT, InputTypes.CHECKBOX, InputTypes.RADIO], defaultName);
+        if (isOptionsBasedField && options.length === 0) {
+            // Don't show Default Value field if no options exist
+            setDefaultValueInput(null);
+            return;
+        }
+        // Use a specific placeholder for default value input, or fallback to field placeholder
+        const defaultValuePlaceholder = "Enter default value";
+        const item = {
+            _id: "defaultValue",
+            name: "Default Value",
+            defaultName,
+            options,
+            inputTypeSettings: settings,
+            placeholder: defaultValuePlaceholder,
+        };
+        // Add rule: defaultValue must be one of the options when defaultName is SELECT
+        let rules = [];
+        if ((defaultName === InputTypes.SELECT ||
+            defaultName === InputTypes.CHECKBOX ||
+            defaultName === InputTypes.RADIO) &&
+            options.length > 0) {
+            rules.push({
+                validator: (_, value) => {
+                    const allowedValues = options
+                        .filter((opt) => opt)
+                        .map((opt) => opt.value);
+                    if (value === undefined ||
+                        (Array.isArray(value)
+                            ? value.every((v) => allowedValues.includes(v))
+                            : allowedValues.includes(value))) {
+                        return Promise.resolve();
+                    }
+                    return Promise.reject("Default value must be one of the options");
+                },
+            });
+        }
+        // Rule for NUMBERS: reject strings - only accept number type
+        if (defaultName === InputTypes.NUMBERS) {
+            rules.push({
+                validator: (_, value) => {
+                    if (value === undefined || value === null || value === "") {
+                        return Promise.resolve();
+                    }
+                    // Only accept actual number type - reject all strings
+                    if (typeof value !== "number") {
+                        return Promise.reject("Default value must be a number, not text");
+                    }
+                    if (isNaN(value) || !isFinite(value)) {
+                        return Promise.reject("Default value must be a valid number");
+                    }
+                    return Promise.resolve();
+                },
+            });
+        }
+        // Rule for DATE and DATE_RANGE: check time part if allow time is selected
+        if ((defaultName === InputTypes.DATE ||
+            defaultName === InputTypes.DATE_RANGE) &&
+            settings[InputSupportedTypes.ALLOW_TIME] !== undefined) {
+            rules.push({
+                validator: (_, value) => {
+                    const allowTime = !!get(settings, `${InputSupportedTypes.ALLOW_TIME}.allow`);
+                    if (!value)
+                        return Promise.resolve();
+                    // For DATE
+                    if (defaultName === InputTypes.DATE) {
+                        const hasTimeMethods = value &&
+                            typeof value.hour === "function" &&
+                            typeof value.minute === "function" &&
+                            typeof value.second === "function";
+                        if (allowTime && !hasTimeMethods) {
+                            return Promise.reject("Please select a date with time (hour/minute/second).");
+                        }
+                        if (!allowTime && hasTimeMethods) {
+                            return Promise.reject("Time is not allowed. Please select only a date.");
+                        }
+                    }
+                    // For DATE_RANGE
+                    if (defaultName === InputTypes.DATE_RANGE && Array.isArray(value)) {
+                        const [start, end] = value;
+                        const startHasTimeMethods = start &&
+                            typeof start.hour === "function" &&
+                            typeof start.minute === "function" &&
+                            typeof start.second === "function";
+                        const endHasTimeMethods = end &&
+                            typeof end.hour === "function" &&
+                            typeof end.minute === "function" &&
+                            typeof end.second === "function";
+                        if (allowTime && (!startHasTimeMethods || !endHasTimeMethods)) {
+                            return Promise.reject("Please select both start and end dates with time.");
+                        }
+                        if (!allowTime && (startHasTimeMethods || endHasTimeMethods)) {
+                            return Promise.reject("Time is not allowed. Please select only dates.");
+                        }
+                    }
+                    return Promise.resolve();
+                },
+            });
+        }
+        // Pass rules to getFormItem
+        const defaultValueItem = getFormItem(Object.assign(Object.assign({}, item), { additionalRules: rules }), true);
+        setDefaultValueInput(defaultValueItem);
+    };
+    return (_jsxs("div", { className: "md-lib-p-4", children: [_jsxs("div", { className: "md-lib-flex md-lib-items-center md-lib-gap-2", children: [_jsx("h2", { className: "md-lib-text-xl md-lib-font-semibold", children: "Properties" }), _jsxs("p", { className: "md-lib-ml-auto md-lib-text-sm md-lib-truncate", style: { color: styles === null || styles === void 0 ? void 0 : styles.secondaryTextColor }, children: ["Type: ", get(field, "name", "N/A")] })] }), _jsx("div", { className: "md-lib-mt-4 md-lib-relative", children: _jsxs(Form, { layout: "vertical", form: form, requiredMark: true, scrollToFirstError: true, onFinish: onUpdate, initialValues: field, onValuesChange: handleFormValuesChange, className: "md-lib-pb-20", children: [_jsx(Form.Item, { name: "isMandatory", valuePropName: "checked", children: _jsx(Checkbox, { children: "Marks as mandatory field" }) }), _jsx(Form.Item, { name: "name", label: "Name", rules: [
+                                { required: true, message: "Name is required" },
+                                {
+                                    validator: (_, value) => {
+                                        if (!value ||
+                                            !allFields.some((f, i) => f.name === value && i !== index)) {
+                                            return Promise.resolve();
+                                        }
+                                        return Promise.reject("Name must be unique");
+                                    },
+                                },
+                            ], children: _jsx(Input, { placeholder: "Enter name", className: "md-lib-h-12", maxLength: 255, showCount: true }) }), _jsx(Form.Item, { label: "Placeholder", name: "placeholder", rules: [
+                                {
+                                    required: true,
+                                    message: "Placeholder is required",
+                                },
+                            ], children: _jsx(Input, { placeholder: "Enter Field Placeholder", className: "md-lib-h-12", maxLength: 255, showCount: true }) }), defaultValueInput && defaultValueInput, _jsxs("div", { children: [!!get(currentInputType, "supportedTypes.length") && (_jsx("h3", { className: "md-lib-text-md md-lib-font-semibold md-lib-mb-2", children: "Field Validations" })), _jsxs(Form.Item, { name: "field_validations", children: [includes([InputTypes.PARAGRAPH, InputTypes.TEXT, InputTypes.LINK], get(currentInputType, "defaultName")) && (_jsx(TextField, { field: field, supportedTypes: get(currentInputType, "supportedTypes", []) })), get(currentInputType, "defaultName") == InputTypes.NUMBERS && (_jsx(NumberField, { field: field, supportedTypes: get(currentInputType, "supportedTypes", []) })), (get(currentInputType, "defaultName") == InputTypes.DATE ||
+                                            get(currentInputType, "defaultName") ==
+                                                InputTypes.DATE_RANGE) && (_jsx(DateField, { field: field, supportedTypes: get(currentInputType, "supportedTypes", []) })), includes([
+                                            InputTypes.SELECT,
+                                            InputTypes.PERSON,
+                                            InputTypes.TEAM,
+                                            InputTypes.CHECKBOX,
+                                            InputTypes.RADIO,
+                                        ], get(currentInputType, "defaultName")) && (_jsx(OptionsField, { field: field, supportedTypes: get(currentInputType, "supportedTypes", []), currentInputType: currentInputType }))] })] }), _jsxs(Form.Item, { className: "md-lib-flex md-lib-flex-col md-lib-items-end md-lib-absolute md-lib-bottom-0 md-lib-right-0 md-lib-pr-4 md-lib-pb-4", children: [disabledReason && (_jsxs("p", { className: "md-lib-text-sm md-lib-mb-2 md-lib-mr-2", style: { color: styles === null || styles === void 0 ? void 0 : styles.secondaryTextColor }, children: ["Update disabled: ", disabledReason] })), _jsxs("div", { className: "md-lib-flex md-lib-items-center", children: [_jsx(Button, { color: "primary", variant: "text", onClick: () => {
+                                                if (onCancel && index !== null) {
+                                                    onCancel(index);
+                                                }
+                                                else {
+                                                    setCurrentFieldIndex(null);
+                                                }
+                                            }, size: "large", children: "Cancel" }), _jsx(Button, { color: "primary", htmlType: "submit", className: "md-lib-ml-2 md-lib-border-primaryColor md-lib-text-primaryColor", size: "large", loading: loading, disabled: !isFormValid || loading, title: disabledReason || undefined, children: "Update" })] })] })] }) })] }));
+}

package/build/AssetType/AssetTemplatesTable.d.ts

@@ -0,0 +1,10 @@
+import { AssetTemplateEntity } from "../utilities/constants/interface";
+declare function AssetTemplatesTable({ assetTemplates, totalPages, totalCount, filters, onFetchAssetTemplates, loading, }: {
+    assetTemplates: AssetTemplateEntity[];
+    totalPages: number;
+    totalCount: number;
+    filters: any;
+    onFetchAssetTemplates: (params: any) => void;
+    loading: boolean;
+}): JSX.Element;
+export default AssetTemplatesTable;

package/build/AssetType/AssetTemplatesTable.js

@@ -0,0 +1,172 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Space, Table, Tooltip, Switch } from "antd";
+import { useMemo, useState } from "react";
+import { get } from "lodash";
+import { APP_DATE_TIME_FORMAT, DEFAULT_PAGE, LOCAL_TIMEZONE, } from "../hocs/appConstants";
+import { NotificationStatus, SortOrders, } from "../utilities/constants/interface";
+import CustomLoader from "../common/loader/CustomLoader";
+import { EditOutlined, DeleteOutlined } from "@ant-design/icons";
+import CustomButton from "../common/Button";
+import { ASSET_TEMPLATE_SCREEN } from "../utilities/constants/routes";
+import moment from "moment-timezone";
+import { DeleteConfirmationModal, RenderTableSearchFilters, RenderTableSelectFilters, } from "../common/CustomElements";
+import { DEACTIVATE_OK_TEXT, DELETE_CONFIRMATION_MESSAGE, DELETE_OK_TEXT, DELETE_SUCCESS, SOMETHING_WENT_WRONG, UPDATE_SUCCESS, } from "../utilities/constants/messages";
+import { showNotification } from "../common/notifications";
+import { FETCH_ASSET_URL } from "../utilities/constants/apiUrls";
+import { useDamConfig } from "../hocs/DamConfigContext";
+import { createApiClient } from "../hocs/configureAxios";
+import useAppNavigate from "../utilities/useAppNavigate";
+function AssetTemplatesTable({ assetTemplates, totalPages, totalCount, filters = {}, onFetchAssetTemplates, loading, }) {
+    const [state, setState] = useState({
+        showConfirmPopup: false,
+        selectedAsset: {},
+        actionLoading: false,
+        updateAssetId: "",
+    });
+    const navigate = useAppNavigate();
+    const damConfig = useDamConfig();
+    const api = useMemo(() => createApiClient(damConfig), [damConfig]);
+    const { showConfirmPopup, selectedAsset, actionLoading, updateAssetId } = state;
+    const toggleDeletConfirm = (asset = {}, updateAssetId = "") => {
+        setState((prevState) => (Object.assign(Object.assign({}, prevState), { selectedAsset: asset, showConfirmPopup: !prevState.showConfirmPopup, actionLoading: false, updateAssetId: updateAssetId })));
+    };
+    const onDeleteTemplate = () => __awaiter(this, void 0, void 0, function* () {
+        const assetId = get(selectedAsset, "_id");
+        if (!assetId) {
+            showNotification("Unable to delete: Asset ID is missing", NotificationStatus.ERROR);
+            toggleDeletConfirm();
+            return;
+        }
+        setState((prevState) => (Object.assign(Object.assign({}, prevState), { actionLoading: true })));
+        try {
+            const response = yield api.delete(FETCH_ASSET_URL.replace(":assetId", assetId));
+            onFetchAssetTemplates(Object.assign(Object.assign({}, filters), { page: DEFAULT_PAGE }));
+            toggleDeletConfirm();
+            showNotification(get(response, "data.message", DELETE_SUCCESS), NotificationStatus.SUCCESS);
+        }
+        catch (error) {
+            setState((prevState) => (Object.assign(Object.assign({}, prevState), { actionLoading: false })));
+            const errorMessage = get(error, "response.data.message") ||
+                get(error, "message") ||
+                SOMETHING_WENT_WRONG;
+            showNotification(errorMessage, NotificationStatus.ERROR);
+        }
+    });
+    const onUpdateTemplate = (values, assetId) => __awaiter(this, void 0, void 0, function* () {
+        setState((prevState) => (Object.assign(Object.assign({}, prevState), { actionLoading: true })));
+        try {
+            const response = yield api.put(FETCH_ASSET_URL.replace(":assetId", assetId), values);
+            onFetchAssetTemplates(filters);
+            toggleDeletConfirm();
+            showNotification(get(response, "data.message", UPDATE_SUCCESS), NotificationStatus.SUCCESS);
+        }
+        catch (error) {
+            setState((prevState) => (Object.assign(Object.assign({}, prevState), { actionLoading: false })));
+            showNotification(get(error, "message", SOMETHING_WENT_WRONG), NotificationStatus.ERROR);
+        }
+    });
+    const getSortOrder = (order) => {
+        if (order === SortOrders.ASCEND) {
+            return "ascend";
+        }
+        else if (order === SortOrders.DESCEND) {
+            return "descend";
+        }
+    };
+    const columns = [
+        {
+            title: "Template Name",
+            dataIndex: "name",
+            key: "templateName",
+            sortOrder: filters.sortBy == "name" ? getSortOrder(filters.sortOrder) : undefined,
+            filteredValue: filters.name ? [filters.name] : [],
+            filterDropdown: ({ setSelectedKeys, selectedKeys, confirm, clearFilters, }) => {
+                return (_jsx(RenderTableSearchFilters, { value: selectedKeys[0] || "", onChange: (e) => setSelectedKeys(e.target.value ? [e.target.value] : []), placeholder: "Search name", onPressEnter: confirm, onClick: confirm, onClear: () => {
+                        clearFilters();
+                        setSelectedKeys([]);
+                        confirm();
+                    } }));
+            },
+            sorter: true,
+            render: (text) => (_jsx("span", { className: "md-lib-text-textColor dark:md-lib-text-darkTextColor md-lib-max-w-[200px] md-lib-truncate md-lib-inline-block md-lib-cursor-default", title: text, children: text })),
+        },
+        {
+            title: "Created at",
+            dataIndex: "createdAt",
+            key: "createdAt",
+            sorter: true,
+            sortOrder: filters.sortBy == "createdAt"
+                ? getSortOrder(filters.sortOrder)
+                : undefined,
+            width: 200,
+            render: (date) => (_jsx("span", { className: "md-lib-text-secondaryTextColor dark:md-lib-text-darkSecondaryTextColor md-lib-text-sm md-lib-cursor-default", children: moment.utc(date).tz(LOCAL_TIMEZONE).format(APP_DATE_TIME_FORMAT) })),
+        },
+        {
+            title: "Description",
+            dataIndex: "description",
+            key: "description",
+            render: (text) => (_jsx("span", { className: "md-lib-text-secondaryTextColor dark:md-lib-text-darkSecondaryTextColor md-lib-max-w-[240px] md-lib-truncate md-lib-inline-block md-lib-text-sm md-lib-cursor-default", title: text, children: text })),
+        },
+        {
+            title: "Active",
+            dataIndex: "isActive",
+            key: "isActive",
+            align: "center",
+            filteredValue: filters.isActive ? filters.isActive : null,
+            render: (isActive, record) => (_jsx(Switch, { loading: updateAssetId === get(record, "_id") && actionLoading, checked: isActive, onChange: (checked) => {
+                    if (isActive) {
+                        toggleDeletConfirm(record, get(record, "_id"));
+                    }
+                    else {
+                        onUpdateTemplate({ isActive: !isActive }, get(record, "_id"));
+                    }
+                } })),
+            filterDropdown: ({ setSelectedKeys, selectedKeys, confirm, clearFilters, }) => (_jsx(RenderTableSelectFilters, { selectedKeys: selectedKeys, onChange: (value) => setSelectedKeys(value), placeholder: "Is active?", onClear: () => {
+                    clearFilters();
+                    setSelectedKeys([]);
+                    confirm();
+                }, onClick: confirm })),
+        },
+        {
+            title: "Actions",
+            dataIndex: "",
+            key: "actions",
+            render: (record) => (_jsxs(Space, { children: [_jsx(Tooltip, { title: "Edit Asset template", className: "md-lib-hidden md:md-lib-block", children: _jsx(CustomButton, { icon: _jsx(EditOutlined, { size: 24, className: "md-lib-text-primaryColor" }), size: "large", label: "", className: "md-lib-border-none", onClick: () => {
+                                if (navigate) {
+                                    navigate(ASSET_TEMPLATE_SCREEN.replace(":id", get(record, "_id")));
+                                }
+                            } }) }), _jsx(Tooltip, { title: "Delete Asset template", placement: "topLeft", children: _jsx(CustomButton, { icon: _jsx(DeleteOutlined, { className: "md-lib-text-dangerColor", size: 24 }), label: "", type: "default", onClick: () => toggleDeletConfirm(record), className: "md-lib-border-none", size: "large" }) })] })),
+        },
+    ];
+    const handleTableChange = (pagination, tableFilters, sorter) => {
+        const order = sorter.order === "ascend" ? SortOrders.ASCEND : SortOrders.DESCEND;
+        const sortBy = sorter.field;
+        const updatedFilters = Object.assign(Object.assign({}, filters), { page: get(pagination, "current"), name: get(tableFilters, "templateName")
+                ? get(tableFilters, "templateName[0]")
+                : "", isActive: get(tableFilters, "isActive")
+                ? get(tableFilters, "isActive")
+                : undefined, sortBy: sortBy, sortOrder: order });
+        onFetchAssetTemplates(updatedFilters);
+    };
+    return (_jsxs("div", { className: "md-lib-mt-4", children: [_jsx(Table, { columns: columns, dataSource: assetTemplates, loading: { spinning: loading, indicator: _jsx(CustomLoader, {}) }, className: "assetType-table", pagination: totalPages > 1
+                    ? {
+                        showSizeChanger: false,
+                        total: totalCount,
+                        current: filters.page || DEFAULT_PAGE,
+                    }
+                    : false, onChange: handleTableChange, scroll: { x: "100%" } }), _jsx(DeleteConfirmationModal, { showDeleteModal: showConfirmPopup, toggleDeleteModal: toggleDeletConfirm, okText: updateAssetId ? DEACTIVATE_OK_TEXT : DELETE_OK_TEXT, onOk: updateAssetId
+                    ? () => onUpdateTemplate({ isActive: false }, get(selectedAsset, "_id"))
+                    : onDeleteTemplate, loading: actionLoading, description: DELETE_CONFIRMATION_MESSAGE.replace(":action", updateAssetId ? "deactivate" : "delete").replace(":entity", `${get(selectedAsset, "name", "this asset template")}`), subHeading: updateAssetId
+                    ? ""
+                    : "Deleting this template might result in loosing all the meta data associated with this asset type. This change is irreversible." })] }));
+}
+export default AssetTemplatesTable;

package/build/AssetType/CreateAssetTemplate.d.ts

@@ -0,0 +1,3 @@
+export default function CreateAssetTemplate({ label }: {
+    label: string;
+}): JSX.Element;