awing-library 2.1.2-dev.99 → 2.1.2-preview.1

package/dist/Helpers/query.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Available filter operation types
+ */
+export declare enum FilterOperationType {
+    EQ = "eq",// Equal
+    CONTAINS = "contains",// Contains substring
+    STARTSWITH = "startswith",// Starts with
+    ENDSWITH = "endswith",// Ends with
+    GT = "gt",// Greater than
+    GTE = "gte",// Greater than or equal
+    LT = "lt",// Less than
+    LTE = "lte",// Less than or equal
+    IN = "in",// In array
+    BETWEEN = "between",// Between two values
+    NE = "ne",// Not equal
+    NOTCONTAINS = "notcontains",// Does not contain substring
+    NOTIN = "notin",// Not in array
+    ISEMPTY = "isempty",// Check if the field is empty (null, undefined or empty string)
+    ISNULL = "isnull",// Check if the field is null
+    CUSTOM = "custom"
+}
+/**
+ * Logical operators for combining filter conditions
+ */
+export declare enum LogicalOperatorType {
+    AND = "and",
+    OR = "or",
+    NOT = "not"
+}
+/**
+ * Structure for a single filter item
+ */
+export interface FilterItem {
+    key: string;
+    value: any;
+    type: FilterOperationType | string;
+}
+/**
+ * Structure for a filter group that can contain nested conditions
+ */
+export interface FilterGroup {
+    operator: LogicalOperatorType;
+    filters: Array<FilterItem | FilterGroup>;
+}
+/**
+ * Filter expression can be either a single item or a group
+ */
+export type FilterExpression = FilterItem | FilterGroup;
+/**
+ * Converts an array of filter objects to a string condition
+ * @param filters - Array of objects with key, value, and type properties
+ * @param defaultOperator - Default logical operator to use when combining filters (AND or OR)
+ * @returns Object with a 'condition' property containing the string condition
+ */
+export declare function convertArrayFiltersToCondition(filters: Array<FilterItem>, defaultOperator?: LogicalOperatorType): {
+    condition: string;
+} | null;
+/**
+ * Helper function to escape special characters for query strings
+ * @param val - The string value to escape
+ * @returns The escaped string
+ */
+export declare function escapeValue(val: string): string;
+/**
+ * Converts a complex filter expression to a string condition
+ * @param filterExpression - Filter expression (can be nested with logical operators)
+ * @returns Object with a 'condition' property containing the string condition and optional 'params' array
+ */
+export declare function convertFilterExpressionToCondition(filterExpression: FilterExpression): {
+    condition: string;
+    params?: string[];
+} | null;
+/**
+ * Usage examples:
+ *  * Simple filter with AND:
+ * ```typescript
+ * const filters: FilterItem[] = [
+ *   { key: 'name', value: 'John', type: FilterOperationType.CONTAINS },
+ *   { key: 'age', value: 30, type: FilterOperationType.GTE }
+ * ];
+ * const result = convertArrayFiltersToCondition(filters); // name.Contains("John") && age>=30
+ * ```
+ *
+ * Simple filter with OR:
+ * ```typescript
+ * const filters: FilterItem[] = [
+ *   { key: 'status', value: 'active', type: FilterOperationType.EQ },
+ *   { key: 'status', value: 'pending', type: FilterOperationType.EQ }
+ * ];
+ * const result = convertArrayFiltersToCondition(filters, LogicalOperatorType.OR); // status="active" || status="pending"
+ * ```
+ *
+ * Filter with isArray property:
+ * ```typescript
+ * const filters: FilterItem[] = [
+ *   { key: 'objectTypeCode', value: 'OBJECTFILTER', type: FilterOperationType.EQ, isArray: false },
+ *   { key: 'name', value: 'Long', type: FilterOperationType.EQ, isArray: true },
+ * ];
+ * const result = convertArrayFiltersToCondition(filters);
+ * // Returns: { condition: 'objectTypeCode="OBJECTFILTER" && @0.Contains(name)', params: ["Long"] }
+ * ```
+ *
+ * Filter with isArray and array values:
+ * ```typescript
+ * const filters: FilterItem[] = [
+ *   { key: 'id', value: [1, 2, 3], type: FilterOperationType.EQ, isArray: true },
+ *   { key: 'names', value: ['name1', 'name2', 'name3'], type: FilterOperationType.EQ, isArray: true },
+ * ];
+ * const result = convertArrayFiltersToCondition(filters);
+ * // Returns: { condition: '@0.Contains(id) && @1.Contains(names)', params: ["[1,2,3]", "[\"name1\",\"name2\",\"name3\"]"] }
+ * ```
+ *
+ * Complex nested filter:
+ * ```typescript
+ * const complexFilter: FilterGroup = {
+ *   operator: LogicalOperatorType.AND,
+ *   filters: [
+ *     { key: 'name', value: 'John', type: FilterOperationType.CONTAINS },
+ *     {
+ *       operator: LogicalOperatorType.OR,
+ *       filters: [
+ *         { key: 'age', value: 30, type: FilterOperationType.GTE },
+ *         { key: 'vip', value: true, type: FilterOperationType.EQ }
+ *       ]
+ *     },
+ *     {
+ *       operator: LogicalOperatorType.NOT,
+ *       filters: [
+ *         { key: 'status', value: 'inactive', type: FilterOperationType.EQ }
+ *       ]
+ *     }
+ *   ]
+ * };
+ * const result = convertFilterExpressionToCondition(complexFilter);
+ * // name.Contains("John") && (age>=30 || vip="true") && !(status="inactive")
+ * ```
+ *
+ * Complex filter with parameterized values:
+ * ```typescript
+ * const complexFilter: FilterGroup = {
+ *   operator: LogicalOperatorType.AND,
+ *   filters: [
+ *     { key: 'objectTypeCode', value: 'OBJECTFILTER', type: FilterOperationType.EQ },
+ *     { key: 'name', value: 'Long', type: FilterOperationType.EQ, isArray: true }
+ *   ]
+ * };
+ * const result = convertFilterExpressionToCondition(complexFilter);
+ * // Returns: { condition: 'objectTypeCode="OBJECTFILTER" && @0.Contains(name)', params: ["Long"] }
+ * ```
+ *
+ * Complex filter with array values:
+ * ```typescript
+ * const complexFilter: FilterGroup = {
+ *   operator: LogicalOperatorType.AND,
+ *   filters: [
+ *     { key: 'objectTypeCode', value: 'OBJECTFILTER', type: FilterOperationType.EQ },
+ *     { key: 'id', value: [1, 2], type: FilterOperationType.EQ, isArray: true },
+ *     { key: 'name', value: ['name1', 'name2'], type: FilterOperationType.EQ, isArray: true }
+ *   ]
+ * };
+ * const result = convertFilterExpressionToCondition(complexFilter);
+ * // Returns: {
+ * //   condition: 'objectTypeCode="OBJECTFILTER" && @0.Contains(id) && @1.Contains(name)',
+ * //   params: ["[1,2]", "[\"name1\",\"name2\"]"]
+ * // }
+ * ```
+ *
+ * Example with ISEMPTY check:
+ * ```typescript
+ * const complexFilter: FilterGroup = {
+ *   operator: LogicalOperatorType.AND,
+ *   filters: [
+ *     {
+ *       operator: LogicalOperatorType.OR,
+ *       filters: [
+ *         { key: 'apControllerCode', value: 'aerohive', type: FilterOperationType.CONTAINS },
+ *         { key: 'apControllerCode', type: FilterOperationType.ISEMPTY }
+ *       ]
+ *     },
+ *     { key: 'authenticationMethodCode', value: 'standard', type: FilterOperationType.CONTAINS }
+ *   ]
+ * };
+ * const result = convertFilterExpressionToCondition(complexFilter);
+ * // Returns: { condition: '(apControllerCode.Contains("aerohive") || apControllerCode == string.Empty) && authenticationMethodCode.Contains("standard")' }
+ * ```
+ *
+ * Example with ISNULL check:
+ * ```typescript
+ * const complexFilter: FilterGroup = {
+ *   operator: LogicalOperatorType.AND,
+ *   filters: [
+ *     {
+ *       operator: LogicalOperatorType.OR,
+ *       filters: [
+ *         { key: 'description', value: 'active', type: FilterOperationType.CONTAINS },
+ *         { key: 'description', type: FilterOperationType.ISNULL }
+ *       ]
+ *     },
+ *     { key: 'status', value: 'enabled', type: FilterOperationType.EQ }
+ *   ]
+ * };
+ * const result = convertFilterExpressionToCondition(complexFilter);
+ * // Returns: { condition: '(description.Contains("active") || description == null) && status="enabled"' }
+ * ```
+ */ 
+//# sourceMappingURL=query.d.ts.map

package/dist/Helpers/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/Helpers/query.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,mBAAmB;IAC3B,EAAE,OAAO,CAAE,QAAQ;IACnB,QAAQ,aAAa,CAAE,qBAAqB;IAC5C,UAAU,eAAe,CAAE,cAAc;IACzC,QAAQ,aAAa,CAAE,YAAY;IACnC,EAAE,OAAO,CAAE,eAAe;IAC1B,GAAG,QAAQ,CAAE,wBAAwB;IACrC,EAAE,OAAO,CAAE,YAAY;IACvB,GAAG,QAAQ,CAAE,qBAAqB;IAClC,EAAE,OAAO,CAAE,WAAW;IACtB,OAAO,YAAY,CAAE,qBAAqB;IAC1C,EAAE,OAAO,CAAE,YAAY;IACvB,WAAW,gBAAgB,CAAE,6BAA6B;IAC1D,KAAK,UAAU,CAAE,eAAe;IAChC,OAAO,YAAY,CAAE,gEAAgE;IACrF,MAAM,WAAW,CAAE,6BAA6B;IAChD,MAAM,WAAW;CACpB;AAED;;GAEG;AACH,oBAAY,mBAAmB;IAC3B,GAAG,QAAQ;IACX,EAAE,OAAO;IACT,GAAG,QAAQ;CACd;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,GAAG,CAAC;IACX,IAAI,EAAE,mBAAmB,GAAG,MAAM,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,OAAO,EAAE,KAAK,CAAC,UAAU,GAAG,WAAW,CAAC,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,WAAW,CAAC;AAExD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC1C,OAAO,EAAE,KAAK,CAAC,UAAU,CAAC,EAC1B,eAAe,GAAE,mBAA6C,GAC/D;IACC,SAAS,EAAE,MAAM,CAAC;CACrB,GAAG,IAAI,CAmDP;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAM3C;AAiLL;;;;GAIG;AACH,wBAAgB,kCAAkC,CAC9C,gBAAgB,EAAE,gBAAgB,GACnC;IACC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB,GAAG,IAAI,CAmBP;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoIG"}

package/dist/Helpers/query.js

@@ -0,0 +1,166 @@
+var query_FilterOperationType = /*#__PURE__*/ function(FilterOperationType) {
+    FilterOperationType["EQ"] = "eq";
+    FilterOperationType["CONTAINS"] = "contains";
+    FilterOperationType["STARTSWITH"] = "startswith";
+    FilterOperationType["ENDSWITH"] = "endswith";
+    FilterOperationType["GT"] = "gt";
+    FilterOperationType["GTE"] = "gte";
+    FilterOperationType["LT"] = "lt";
+    FilterOperationType["LTE"] = "lte";
+    FilterOperationType["IN"] = "in";
+    FilterOperationType["BETWEEN"] = "between";
+    FilterOperationType["NE"] = "ne";
+    FilterOperationType["NOTCONTAINS"] = "notcontains";
+    FilterOperationType["NOTIN"] = "notin";
+    FilterOperationType["ISEMPTY"] = "isempty";
+    FilterOperationType["ISNULL"] = "isnull";
+    FilterOperationType["CUSTOM"] = "custom";
+    return FilterOperationType;
+}({});
+var query_LogicalOperatorType = /*#__PURE__*/ function(LogicalOperatorType) {
+    LogicalOperatorType["AND"] = "and";
+    LogicalOperatorType["OR"] = "or";
+    LogicalOperatorType["NOT"] = "not";
+    return LogicalOperatorType;
+}({});
+function convertArrayFiltersToCondition(filters, defaultOperator = "and") {
+    if (!filters || 0 === filters.length) return null;
+    const conditions = [];
+    filters.forEach(({ key, value, type })=>{
+        const typeStr = 'string' == typeof type ? type.toLowerCase() : type;
+        if ("isempty" !== typeStr && "isnull" !== typeStr && (void 0 === value || '' === value || null === value)) return;
+        if (Array.isArray(value) && "in" !== typeStr && "notin" !== typeStr && "between" !== typeStr) {
+            const arrayConditions = [];
+            value.forEach((singleValue)=>{
+                const singleCondition = createSingleCondition(key, singleValue, typeStr);
+                if (singleCondition) arrayConditions.push(singleCondition);
+            });
+            if (arrayConditions.length > 0) {
+                const arrayConditionStr = arrayConditions.length > 1 ? `(${arrayConditions.join(' || ')})` : arrayConditions[0];
+                conditions.push(arrayConditionStr);
+            }
+        } else {
+            const condition = createSingleCondition(key, value, typeStr);
+            if (condition) conditions.push(condition);
+        }
+    });
+    const logicalOperator = "or" === defaultOperator ? ' || ' : ' && ';
+    const conditionString = conditions.join(logicalOperator);
+    if ("" === conditionString) return null;
+    return {
+        condition: conditionString
+    };
+}
+function escapeValue(val) {
+    return val.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\//g, '\\/').replace(/'/g, '\'\'');
+}
+function createSingleCondition(key, value, typeStr) {
+    let condition;
+    switch(typeStr){
+        case "eq":
+            if ('boolean' == typeof value || 'number' == typeof value) {
+                condition = `${key}=${value}`;
+                break;
+            }
+            condition = `${key}="${value}"`;
+            break;
+        case "contains":
+            condition = `${key}.Contains("${escapeValue(value)}")`;
+            break;
+        case "startswith":
+            condition = `${key}.StartsWith("${escapeValue(value)}")`;
+            break;
+        case "endswith":
+            condition = `${key}.EndsWith("${escapeValue(value)}")`;
+            break;
+        case "gt":
+            condition = `${key}>${value}`;
+            break;
+        case "gte":
+            condition = `${key}>=${value}`;
+            break;
+        case "lt":
+            condition = `${key}<${value}`;
+            break;
+        case "lte":
+            condition = `${key}<=${value}`;
+            break;
+        case "isempty":
+            condition = `${key} == string.Empty`;
+            break;
+        case "isnull":
+            condition = `${key} == null`;
+            break;
+        case "in":
+            condition = Array.isArray(value) ? `${key} IN (${value.map((v)=>'string' == typeof v ? `"${v}"` : v).join(', ')})` : `${key} IN ("${value}")`;
+            break;
+        case "between":
+            condition = Array.isArray(value) && 2 === value.length ? `(${key} >= ${value[0]} && ${key} <= ${value[1]})` : `${key} BETWEEN ${value}`;
+            break;
+        case "ne":
+            condition = `${key}!="${value}"`;
+            break;
+        case "notcontains":
+            condition = `!${key}.Contains("${escapeValue(value)}")`;
+            break;
+        case "notin":
+            condition = Array.isArray(value) ? `${key} NOT IN (${value.map((v)=>'string' == typeof v ? `"${v}"` : v).join(', ')})` : `${key} NOT IN ("${value}")`;
+            break;
+        case "custom":
+            condition = value;
+            break;
+        default:
+            const operatorName = 'string' == typeof typeStr ? typeStr : 'custom';
+            condition = `${key}.${operatorName}("${value}")`;
+    }
+    return condition;
+}
+function processFilterExpression(expression, isRoot = true, params = []) {
+    if ('operator' in expression) {
+        const group = expression;
+        const conditions = [];
+        group.filters.forEach((filter)=>{
+            const condition = processFilterExpression(filter, false, params);
+            if (condition) conditions.push(condition);
+        });
+        if (0 === conditions.length) return '';
+        let result;
+        switch(group.operator){
+            case "or":
+                result = conditions.join(' || ');
+                break;
+            case "not":
+                result = `!(${conditions.join(' && ')})`;
+                break;
+            case "and":
+            default:
+                result = conditions.join(' && ');
+        }
+        return !isRoot && conditions.length > 1 ? `(${result})` : result;
+    }
+    const item = expression;
+    const { key, value, type } = item;
+    const typeStr = 'string' == typeof type ? type.toLowerCase() : type;
+    if ("isempty" !== typeStr && "isnull" !== typeStr && (void 0 === value || '' === value || null === value)) return '';
+    if (Array.isArray(value) && "in" !== typeStr && "notin" !== typeStr && "between" !== typeStr) {
+        const arrayConditions = [];
+        value.forEach((singleValue)=>{
+            const singleCondition = createSingleCondition(key, singleValue, typeStr);
+            if (singleCondition) arrayConditions.push(singleCondition);
+        });
+        if (arrayConditions.length > 0) return arrayConditions.length > 1 ? `(${arrayConditions.join(' || ')})` : arrayConditions[0];
+        return '';
+    }
+    return createSingleCondition(key, value, typeStr);
+}
+function convertFilterExpressionToCondition(filterExpression) {
+    const params = [];
+    const conditionString = processFilterExpression(filterExpression, true, params);
+    if (!conditionString) return null;
+    const result = {
+        condition: conditionString
+    };
+    if (params.length > 0) result.params = params;
+    return result;
+}
+export { query_FilterOperationType as FilterOperationType, query_LogicalOperatorType as LogicalOperatorType, convertArrayFiltersToCondition, convertFilterExpressionToCondition, escapeValue };

package/dist/Helpers/text.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hỗ trợ xử lý chuỗi văn bản, từ việc định dạng, chuyển đổi cho đến kiểm tra tính hợp lệ.
+ * Đảm bảo sự nhất quán và tái sử dụng các logic liên quan đến chuỗi.
+ */
+export declare function changeToAlias(str?: string): string;
+export declare const toCapitalize: (str: string, lower?: boolean) => string;
+//# sourceMappingURL=text.d.ts.map

package/dist/Helpers/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/Helpers/text.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,wBAAgB,aAAa,CAAC,GAAG,GAAE,MAAW,UAgB7C;AAED,eAAO,MAAM,YAAY,QAAS,MAAM,4BAC6D,CAAC"}

package/dist/Helpers/text.js

@@ -0,0 +1,5 @@
+function changeToAlias(str = '') {
+    return str.trim().normalize('NFD').toLowerCase().replace(/\s\s+/g, ' ').replace(/[\u0300-\u036f]/g, '').replace(/đ/g, 'd').replace(/`|~|!|@|"|#|\||\$|%|\^|&|\*|\(|\)|\+|=|,|\.|\/|\?|>|<|'|"|:|;|_/gi, '').replace(/ /g, '-').replace(/-----/gi, '-').replace(/----/gi, '-').replace(/---/gi, '-').replace(/--/gi, '-').replace(/"-|-"|"/gi, '');
+}
+const toCapitalize = (str, lower = false)=>(lower ? str.toLowerCase() : str).replace(/(?:^|\s|["'([{])+\S/g, (match)=>match.toUpperCase());
+export { changeToAlias, toCapitalize };

package/dist/Helpers/validation.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Đảm bảo dữ liệu được kiểm tra tính hợp lệ trước khi xử lý hoặc gửi đi.
+ * Được sử dụng nhiều trong xử lý form, API, hoặc đầu vào từ người dùng.
+ */
+/**
+ *  check string list ap input
+ *
+ * @param {string} stringListAP
+ * @returns {boolean}
+ */
+export declare function checkValidStringListAP(stringListAP?: string): boolean;
+export declare function checkValidMacAddress(string?: string): boolean;
+export declare function checkValidUrl(url: string | undefined): boolean;
+export declare function validateNumber(value?: string | number): boolean;
+//# sourceMappingURL=validation.d.ts.map

package/dist/Helpers/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/Helpers/validation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AAGH,wBAAgB,sBAAsB,CAAC,YAAY,SAAK,WAcvD;AAED,wBAAgB,oBAAoB,CAAC,MAAM,SAAK,WAG/C;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,WAIpD;AAED,wBAAgB,cAAc,CAAC,KAAK,GAAE,MAAM,GAAG,MAAW,WAMzD"}

package/dist/Helpers/validation.js

@@ -0,0 +1,27 @@
+function checkValidStringListAP(stringListAP = '') {
+    let isValid = true;
+    const listAP = stringListAP.split('\n');
+    listAP.every((ap)=>{
+        const [macAp, nameAp] = ap.split(' ');
+        const regexMacAddress = /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})|([0-9a-fA-F]{4}\\.[0-9a-fA-F]{4}\\.[0-9a-fA-F]{4})$/g;
+        const isValidMacAddress = macAp == macAp.match(regexMacAddress);
+        if (!isValidMacAddress || !nameAp || listAP.filter((item)=>item.includes(macAp)).length > 1) isValid = false;
+        return isValid;
+    });
+    return !isValid;
+}
+function checkValidMacAddress(string = '') {
+    const regexMacAddress = /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})|([0-9a-fA-F]{4}\\.[0-9a-fA-F]{4}\\.[0-9a-fA-F]{4})$/g;
+    return regexMacAddress.test(string);
+}
+function checkValidUrl(url) {
+    var pattern = /^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$/;
+    if (!url || url.length > 1000 || url.trim().length <= 0 || !pattern.test(url)) return false;
+    return true;
+}
+function validateNumber(value = '') {
+    var numberRex = new RegExp('^[0-9]+$');
+    if (numberRex.test(String(value))) return true;
+    return false;
+}
+export { checkValidMacAddress, checkValidStringListAP, checkValidUrl, validateNumber };

package/dist/Layouts/Atom.d.ts

@@ -0,0 +1,14 @@
+import type { Workspace, MenuPermission } from './Types';
+export declare const currentWorkspaceState: import("jotai").PrimitiveAtom<Workspace> & {
+    init: Workspace;
+};
+export declare const menuPermissionsState: import("jotai").PrimitiveAtom<MenuPermission[]> & {
+    init: MenuPermission[];
+};
+export declare const totalDefaultFavoriteWorkspaceState: import("jotai").PrimitiveAtom<number> & {
+    init: number;
+};
+export declare const workspaceIdsState: import("jotai").PrimitiveAtom<number[]> & {
+    init: number[];
+};
+//# sourceMappingURL=Atom.d.ts.map

package/dist/Layouts/Atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Atom.d.ts","sourceRoot":"","sources":["../../src/Layouts/Atom.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAGzD,eAAO,MAAM,qBAAqB;;CAAsB,CAAC;AAEzD,eAAO,MAAM,oBAAoB;;CAA6B,CAAC;AAE/D,eAAO,MAAM,kCAAkC;;CAAkB,CAAC;AAElE,eAAO,MAAM,iBAAiB;;CAAqB,CAAC"}

package/dist/Layouts/Atom.js

@@ -0,0 +1,6 @@
+import { atom } from "jotai";
+const currentWorkspaceState = atom({});
+const menuPermissionsState = atom([]);
+const totalDefaultFavoriteWorkspaceState = atom(0);
+const workspaceIdsState = atom([]);
+export { currentWorkspaceState, menuPermissionsState, totalDefaultFavoriteWorkspaceState, workspaceIdsState };

package/dist/Layouts/Constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DRAWER_WIDTH = 240;
+//# sourceMappingURL=Constants.d.ts.map

package/dist/Layouts/Constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Constants.d.ts","sourceRoot":"","sources":["../../src/Layouts/Constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,MAAM,CAAC"}

package/dist/Layouts/Constants.js

@@ -0,0 +1,2 @@
+const DRAWER_WIDTH = 240;
+export { DRAWER_WIDTH };

package/dist/Layouts/Container.d.ts

@@ -0,0 +1,15 @@
+import { LayoutServices } from './Services';
+import type { MenuPermission, RouteItem, Workspace } from './Types';
+export type ContainerProps = {
+    appName: string;
+    currentWorkspace: Workspace;
+    isShowLayout?: boolean;
+    routeList?: RouteItem[];
+    menuPermission?: MenuPermission[];
+    services?: LayoutServices;
+    totalDefaultFavoriteWorkspace?: number;
+    workspaceIds?: number[];
+};
+declare function Container(props: ContainerProps): import("react/jsx-runtime").JSX.Element;
+export default Container;
+//# sourceMappingURL=Container.d.ts.map

package/dist/Layouts/Container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Container.d.ts","sourceRoot":"","sources":["../../src/Layouts/Container.tsx"],"names":[],"mappings":"AAOA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpE,MAAM,MAAM,cAAc,GAAG;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,SAAS,CAAC;IAC5B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB,cAAc,CAAC,EAAE,cAAc,EAAE,CAAC;IAClC,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,6BAA6B,CAAC,EAAE,MAAM,CAAC;IACvC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B,CAAC;AAEF,iBAAS,SAAS,CAAC,KAAK,EAAE,cAAc,2CAuCvC;AAED,eAAe,SAAS,CAAC"}

package/dist/Layouts/Container.js

@@ -0,0 +1,45 @@
+import { jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { BrowserRouter, Route, Routes } from "react-router";
+import { cloneDeep } from "lodash";
+import { useSetAtom } from "jotai";
+import { LayoutContext } from "./context.js";
+import { currentWorkspaceState, menuPermissionsState, totalDefaultFavoriteWorkspaceState, workspaceIdsState } from "./Atom.js";
+import { renderRoutes } from "./utils.js";
+import Dashboard from "./Dashboard.js";
+function Container(props) {
+    const { appName, isShowLayout = true, services } = props;
+    const setCurrentWorkspace = useSetAtom(currentWorkspaceState);
+    const setMenuPermissions = useSetAtom(menuPermissionsState);
+    const setTotalDefaultFavoriteWorkspace = useSetAtom(totalDefaultFavoriteWorkspaceState);
+    const setWorkspaceIds = useSetAtom(workspaceIdsState);
+    const privateRoutes = useMemo(()=>{
+        const { routeList = [], menuPermission = [], currentWorkspace } = props;
+        setMenuPermissions(menuPermission);
+        setCurrentWorkspace(props.currentWorkspace);
+        props.totalDefaultFavoriteWorkspace && setTotalDefaultFavoriteWorkspace(props.totalDefaultFavoriteWorkspace);
+        props.workspaceIds && setWorkspaceIds(props.workspaceIds);
+        return renderRoutes(cloneDeep(routeList), menuPermission, currentWorkspace.id);
+    }, [
+        props.currentWorkspace,
+        props?.menuPermission
+    ]);
+    return /*#__PURE__*/ jsx(LayoutContext.Provider, {
+        value: {
+            appName,
+            services,
+            routeList: props.routeList
+        },
+        children: /*#__PURE__*/ jsx(BrowserRouter, {
+            children: /*#__PURE__*/ jsx(Routes, {
+                children: isShowLayout && props.currentWorkspace?.id && /*#__PURE__*/ jsx(Route, {
+                    path: "/*",
+                    element: /*#__PURE__*/ jsx(Dashboard, {}),
+                    children: privateRoutes
+                })
+            })
+        })
+    });
+}
+const Layouts_Container = Container;
+export { Layouts_Container as default };

package/dist/Layouts/Dashboard.d.ts

@@ -0,0 +1,3 @@
+declare const Dashboard: () => import("react/jsx-runtime").JSX.Element;
+export default Dashboard;
+//# sourceMappingURL=Dashboard.d.ts.map

package/dist/Layouts/Dashboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dashboard.d.ts","sourceRoot":"","sources":["../../src/Layouts/Dashboard.tsx"],"names":[],"mappings":"AAuDA,QAAA,MAAM,SAAS,+CA6Cd,CAAC;AAEF,eAAe,SAAS,CAAC"}

package/dist/Layouts/Dashboard.js

@@ -0,0 +1,98 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Outlet } from "react-router";
+import { useAtomValue } from "jotai";
+import { AppBar, Container, CssBaseline } from "@mui/material";
+import { styled } from "@mui/material/styles";
+import { currentWorkspaceState, totalDefaultFavoriteWorkspaceState, workspaceIdsState } from "./Atom.js";
+import { useGetLayoutContext } from "./context.js";
+import Footer from "./Footer/index.js";
+import NavDrawer from "./NavDrawer/index.js";
+import Toolbar from "./Toolbar/index.js";
+const RootDiv = styled('div')({
+    display: 'flex',
+    '& #main-content': {
+        outline: 0
+    }
+});
+const StyledAppBar = styled(AppBar)(({ theme })=>({
+        transition: theme.transitions.create('width'),
+        boxShadow: 'none',
+        borderStyle: 'solid',
+        borderColor: 'dark' === theme.palette.mode ? 'rgb(19, 47, 76)' : theme.palette.grey[100],
+        borderWidth: 0,
+        borderBottomWidth: 'thin',
+        background: 'dark' === theme.palette.mode ? theme.palette.background.default : theme.palette.common.white,
+        color: 'dark' === theme.palette.mode ? theme.palette.grey[500] : theme.palette.grey[800],
+        '& .MuiIconButton-root': {
+            color: 'dark' === theme.palette.mode ? theme.palette.common.white : theme.palette.primary.main[500]
+        },
+        lineHeight: 'normal'
+    }));
+const Main = styled('main')(()=>({
+        display: 'flex',
+        width: '100%',
+        fontFamily: '',
+        minHeight: 'calc(100vh - 72px)'
+    }));
+const StyledAppContainer = styled(Container)(({ theme })=>({
+        paddingTop: 90,
+        [theme.breakpoints.up('lg')]: {
+            paddingLeft: theme.spacing(4),
+            paddingRight: theme.spacing(4)
+        },
+        position: 'relative'
+    }));
+const Dashboard_Dashboard = ()=>{
+    const { appName = '', services } = useGetLayoutContext();
+    const currentWorkspace = useAtomValue(currentWorkspaceState);
+    const totalDefaultFavoriteWorkspace = useAtomValue(totalDefaultFavoriteWorkspaceState);
+    const workspaceIds = useAtomValue(workspaceIdsState);
+    const [navDrawerOpen, setNavDrawerOpen] = useState(true);
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: currentWorkspace.id && /*#__PURE__*/ jsxs(RootDiv, {
+            children: [
+                /*#__PURE__*/ jsx(CssBaseline, {}),
+                /*#__PURE__*/ jsx(StyledAppBar, {
+                    children: services && /*#__PURE__*/ jsx(Toolbar, {
+                        currentWorkspace: currentWorkspace,
+                        totalDefaultFavoriteWorkspace: totalDefaultFavoriteWorkspace,
+                        workspaceIds: workspaceIds,
+                        ...services
+                    })
+                }),
+                /*#__PURE__*/ jsx(NavDrawer, {
+                    menuOpen: navDrawerOpen,
+                    toggleMenu: ()=>setNavDrawerOpen(!navDrawerOpen)
+                }),
+                /*#__PURE__*/ jsxs("div", {
+                    style: {
+                        display: 'flex',
+                        flexDirection: 'column',
+                        width: '100%'
+                    },
+                    children: [
+                        /*#__PURE__*/ jsx(Main, {
+                            children: /*#__PURE__*/ jsx(StyledAppContainer, {
+                                id: "main-content",
+                                maxWidth: false,
+                                tabIndex: -1,
+                                children: /*#__PURE__*/ jsx(Outlet, {})
+                            })
+                        }),
+                        /*#__PURE__*/ jsx(Container, {
+                            sx: {
+                                bottom: 0
+                            },
+                            children: /*#__PURE__*/ jsx(Footer, {
+                                appName: appName
+                            })
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+};
+const Dashboard = Dashboard_Dashboard;
+export { Dashboard as default };

package/dist/Layouts/DefaultComponent.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => import("react/jsx-runtime").JSX.Element;
+export default _default;
+//# sourceMappingURL=DefaultComponent.d.ts.map