@nlabs/metropolisjs 0.1.1 → 0.2.0

package/lib/utils/configUtils.d.ts

@@ -0,0 +1,11 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { MetropolisEnvironmentConfiguration } from '../config/index.js';
+/**
+ * Gets configuration from flux state.
+ * Falls back to default config if not found in flux state.
+ *
+ * @param flux - The Flux framework instance
+ * @returns The resolved environment configuration
+ */
+export declare const getConfigFromFlux: (flux: FluxFramework) => MetropolisEnvironmentConfiguration;
+//# sourceMappingURL=configUtils.d.ts.map

package/lib/utils/configUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configUtils.d.ts","sourceRoot":"","sources":["../../src/utils/configUtils.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,oBAAoB,CAAC;AAE7E;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,aAAa,KAAG,kCASvD,CAAC"}

package/lib/utils/configUtils.js

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { getDefaultConfig } from '../config/index.js';
+/**
+ * Gets configuration from flux state.
+ * Falls back to default config if not found in flux state.
+ *
+ * @param flux - The Flux framework instance
+ * @returns The resolved environment configuration
+ */ export const getConfigFromFlux = (flux)=>{
+    const config = flux.getState('app.config');
+    if (config) {
+        return config;
+    }
+    // Fallback to default config
+    return getDefaultConfig();
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L21ldHJvcG9saXNqcy9zcmMvdXRpbHMvY29uZmlnVXRpbHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMjUtUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cbmltcG9ydCB7IGdldERlZmF1bHRDb25maWcgfSBmcm9tICcuLi9jb25maWcvaW5kZXguanMnO1xuaW1wb3J0IHR5cGUgeyBGbHV4RnJhbWV3b3JrIH0gZnJvbSAnQG5sYWJzL2Fya2hhbWpzJztcbmltcG9ydCB0eXBlIHsgTWV0cm9wb2xpc0Vudmlyb25tZW50Q29uZmlndXJhdGlvbiB9IGZyb20gJy4uL2NvbmZpZy9pbmRleC5qcyc7XG5cbi8qKlxuICogR2V0cyBjb25maWd1cmF0aW9uIGZyb20gZmx1eCBzdGF0ZS5cbiAqIEZhbGxzIGJhY2sgdG8gZGVmYXVsdCBjb25maWcgaWYgbm90IGZvdW5kIGluIGZsdXggc3RhdGUuXG4gKlxuICogQHBhcmFtIGZsdXggLSBUaGUgRmx1eCBmcmFtZXdvcmsgaW5zdGFuY2VcbiAqIEByZXR1cm5zIFRoZSByZXNvbHZlZCBlbnZpcm9ubWVudCBjb25maWd1cmF0aW9uXG4gKi9cbmV4cG9ydCBjb25zdCBnZXRDb25maWdGcm9tRmx1eCA9IChmbHV4OiBGbHV4RnJhbWV3b3JrKTogTWV0cm9wb2xpc0Vudmlyb25tZW50Q29uZmlndXJhdGlvbiA9PiB7XG4gIGNvbnN0IGNvbmZpZyA9IGZsdXguZ2V0U3RhdGUoJ2FwcC5jb25maWcnKSBhcyBNZXRyb3BvbGlzRW52aXJvbm1lbnRDb25maWd1cmF0aW9uIHwgdW5kZWZpbmVkO1xuXG4gIGlmIChjb25maWcpIHtcbiAgICByZXR1cm4gY29uZmlnO1xuICB9XG5cbiAgLy8gRmFsbGJhY2sgdG8gZGVmYXVsdCBjb25maWdcbiAgcmV0dXJuIGdldERlZmF1bHRDb25maWcoKTtcbn07XG4iXSwibmFtZXMiOlsiZ2V0RGVmYXVsdENvbmZpZyIsImdldENvbmZpZ0Zyb21GbHV4IiwiZmx1eCIsImNvbmZpZyIsImdldFN0YXRlIl0sIm1hcHBpbmdzIjoiQUFBQTs7O0NBR0MsR0FDRCxTQUFTQSxnQkFBZ0IsUUFBUSxxQkFBcUI7QUFJdEQ7Ozs7OztDQU1DLEdBQ0QsT0FBTyxNQUFNQyxvQkFBb0IsQ0FBQ0M7SUFDaEMsTUFBTUMsU0FBU0QsS0FBS0UsUUFBUSxDQUFDO0lBRTdCLElBQUlELFFBQVE7UUFDVixPQUFPQTtJQUNUO0lBRUEsNkJBQTZCO0lBQzdCLE9BQU9IO0FBQ1QsRUFBRSJ9

package/lib/utils/dateUtils.d.ts

@@ -0,0 +1,3 @@
+import { DateTime } from 'luxon';
+export declare const parseDateTime: (value: string | number | DateTime) => any;
+//# sourceMappingURL=dateUtils.d.ts.map

package/lib/utils/dateUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dateUtils.d.ts","sourceRoot":"","sources":["../../src/utils/dateUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,OAAO,CAAC;AAE/B,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,GAAG,MAAM,GAAG,QAAQ,QAQ9D,CAAC"}

package/lib/utils/dateUtils.js

@@ -0,0 +1,11 @@
+import { DateTime } from 'luxon';
+export const parseDateTime = (value)=>{
+    if (typeof value === 'string') {
+        return DateTime.fromISO(value).toMillis();
+    } else if (value instanceof DateTime) {
+        return value.toMillis();
+    }
+    return value;
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L21ldHJvcG9saXNqcy9zcmMvdXRpbHMvZGF0ZVV0aWxzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RGF0ZVRpbWV9IGZyb20gJ2x1eG9uJztcblxuZXhwb3J0IGNvbnN0IHBhcnNlRGF0ZVRpbWUgPSAodmFsdWU6IHN0cmluZyB8IG51bWJlciB8IERhdGVUaW1lKSA9PiB7XG4gIGlmKHR5cGVvZiB2YWx1ZSA9PT0gJ3N0cmluZycpIHtcbiAgICByZXR1cm4gRGF0ZVRpbWUuZnJvbUlTTyh2YWx1ZSkudG9NaWxsaXMoKTtcbiAgfSBlbHNlIGlmKHZhbHVlIGluc3RhbmNlb2YgRGF0ZVRpbWUpIHtcbiAgICByZXR1cm4gKHZhbHVlIGFzIERhdGVUaW1lKS50b01pbGxpcygpO1xuICB9XG5cbiAgcmV0dXJuIHZhbHVlO1xufTtcbiJdLCJuYW1lcyI6WyJEYXRlVGltZSIsInBhcnNlRGF0ZVRpbWUiLCJ2YWx1ZSIsImZyb21JU08iLCJ0b01pbGxpcyJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBUUEsUUFBUSxRQUFPLFFBQVE7QUFFL0IsT0FBTyxNQUFNQyxnQkFBZ0IsQ0FBQ0M7SUFDNUIsSUFBRyxPQUFPQSxVQUFVLFVBQVU7UUFDNUIsT0FBT0YsU0FBU0csT0FBTyxDQUFDRCxPQUFPRSxRQUFRO0lBQ3pDLE9BQU8sSUFBR0YsaUJBQWlCRixVQUFVO1FBQ25DLE9BQU8sQUFBQ0UsTUFBbUJFLFFBQVE7SUFDckM7SUFFQSxPQUFPRjtBQUNULEVBQUUifQ==

package/lib/utils/file.d.ts

@@ -0,0 +1,3 @@
+export declare const convertFileToUploadFile: (file: File, maxSize: number, maxBytes?: number) => Promise<File>;
+export declare const convertFileToBase64: (file: File, maxSize: number, maxBytes?: number) => Promise<string>;
+//# sourceMappingURL=file.d.ts.map

package/lib/utils/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/utils/file.ts"],"names":[],"mappings":"AAgFA,eAAO,MAAM,uBAAuB,GAClC,MAAM,IAAI,EACV,SAAS,MAAM,EACf,WAAU,MAAmB,KAC5B,OAAO,CAAC,IAAI,CA0Cd,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,MAAM,IAAI,EACV,SAAS,MAAM,EACf,WAAU,MAAmB,KAC5B,OAAO,CAAC,MAAM,CA2Eb,CAAC"}

package/lib/utils/file.js

@@ -0,0 +1,156 @@
+const getUploadPayloadByteSize = (dataUrl)=>dataUrl.length;
+const getFileNameWithoutExtension = (name)=>name.split('.').slice(0, -1).join('.') || name;
+const createImageCanvas = (file, maxSize)=>new Promise((resolve, reject)=>{
+        const image = new Image();
+        const objectUrl = URL.createObjectURL(file);
+        image.onload = ()=>{
+            URL.revokeObjectURL(objectUrl);
+            const canvas = document.createElement('canvas');
+            const { height, width } = image;
+            let updatedHeight = height;
+            let updatedWidth = width;
+            if (width > height) {
+                if (width > maxSize) {
+                    updatedHeight *= maxSize / width;
+                    updatedWidth = maxSize;
+                }
+            } else if (height > maxSize) {
+                updatedWidth *= maxSize / height;
+                updatedHeight = maxSize;
+            }
+            const context = canvas.getContext('2d');
+            if (!context) {
+                reject(new Error('Unable to prepare image upload.'));
+                return;
+            }
+            resolve({
+                canvas,
+                context,
+                height: Math.max(1, Math.round(updatedHeight)),
+                width: Math.max(1, Math.round(updatedWidth))
+            });
+        };
+        image.onerror = ()=>{
+            URL.revokeObjectURL(objectUrl);
+            reject(new Error('Unable to prepare image upload.'));
+        };
+        image.src = objectUrl;
+    });
+const renderImageFile = (canvas, context, image, width, height, quality, name)=>new Promise((resolve, reject)=>{
+        canvas.width = width;
+        canvas.height = height;
+        context.clearRect(0, 0, width, height);
+        context.drawImage(image, 0, 0, width, height);
+        canvas.toBlob((blob)=>{
+            if (!blob) {
+                reject(new Error('Unable to prepare image upload.'));
+                return;
+            }
+            resolve(new File([
+                blob
+            ], `${getFileNameWithoutExtension(name)}.jpg`, {
+                type: 'image/jpeg'
+            }));
+        }, 'image/jpeg', quality);
+    });
+export const convertFileToUploadFile = async (file, maxSize, maxBytes = 900 * 1024)=>{
+    if (!file.type.startsWith('image/') || typeof document === 'undefined') {
+        return file;
+    }
+    const image = new Image();
+    const objectUrl = URL.createObjectURL(file);
+    try {
+        await new Promise((resolve, reject)=>{
+            image.onload = ()=>resolve();
+            image.onerror = ()=>reject(new Error('Unable to prepare image upload.'));
+            image.src = objectUrl;
+        });
+        const { canvas, context, height, width } = await createImageCanvas(file, maxSize);
+        let currentWidth = width;
+        let currentHeight = height;
+        let quality = 0.82;
+        let uploadFile = await renderImageFile(canvas, context, image, currentWidth, currentHeight, quality, file.name);
+        while(uploadFile.size > maxBytes && quality > 0.45){
+            quality = Math.max(0.45, Number((quality - 0.08).toFixed(2)));
+            uploadFile = await renderImageFile(canvas, context, image, currentWidth, currentHeight, quality, file.name);
+        }
+        while(uploadFile.size > maxBytes && (currentWidth > 320 || currentHeight > 320)){
+            currentWidth = Math.max(320, Math.round(currentWidth * 0.85));
+            currentHeight = Math.max(320, Math.round(currentHeight * 0.85));
+            quality = 0.78;
+            uploadFile = await renderImageFile(canvas, context, image, currentWidth, currentHeight, quality, file.name);
+            while(uploadFile.size > maxBytes && quality > 0.45){
+                quality = Math.max(0.45, Number((quality - 0.08).toFixed(2)));
+                uploadFile = await renderImageFile(canvas, context, image, currentWidth, currentHeight, quality, file.name);
+            }
+        }
+        return uploadFile;
+    } finally{
+        URL.revokeObjectURL(objectUrl);
+    }
+};
+export const convertFileToBase64 = (file, maxSize, maxBytes = 900 * 1024)=>new Promise((resolve, reject)=>{
+        const reader = new FileReader();
+        reader.onload = ()=>{
+            const image = new Image();
+            image.onload = ()=>{
+                const canvas = document.createElement('canvas');
+                const { height, width } = image;
+                let updatedHeight = height;
+                let updatedWidth = width;
+                if (width > height) {
+                    if (width > maxSize) {
+                        updatedHeight *= maxSize / width;
+                        updatedWidth = maxSize;
+                    }
+                } else if (height > maxSize) {
+                    updatedWidth *= maxSize / height;
+                    updatedHeight = maxSize;
+                }
+                const context = canvas.getContext('2d');
+                if (!context) {
+                    reject(new Error('Unable to prepare image upload.'));
+                    return;
+                }
+                const renderImage = (width, height)=>{
+                    canvas.width = width;
+                    canvas.height = height;
+                    context.clearRect(0, 0, width, height);
+                    context.drawImage(image, 0, 0, width, height);
+                };
+                let currentWidth = Math.max(1, Math.round(updatedWidth));
+                let currentHeight = Math.max(1, Math.round(updatedHeight));
+                let quality = 0.82;
+                renderImage(currentWidth, currentHeight);
+                let dataUrl = canvas.toDataURL('image/jpeg', quality);
+                let byteSize = getUploadPayloadByteSize(dataUrl);
+                while(byteSize > maxBytes && quality > 0.45){
+                    quality = Math.max(0.45, Number((quality - 0.08).toFixed(2)));
+                    dataUrl = canvas.toDataURL('image/jpeg', quality);
+                    byteSize = getUploadPayloadByteSize(dataUrl);
+                }
+                while(byteSize > maxBytes && (currentWidth > 320 || currentHeight > 320)){
+                    currentWidth = Math.max(320, Math.round(currentWidth * 0.85));
+                    currentHeight = Math.max(320, Math.round(currentHeight * 0.85));
+                    quality = 0.78;
+                    renderImage(currentWidth, currentHeight);
+                    dataUrl = canvas.toDataURL('image/jpeg', quality);
+                    byteSize = getUploadPayloadByteSize(dataUrl);
+                    while(byteSize > maxBytes && quality > 0.45){
+                        quality = Math.max(0.45, Number((quality - 0.08).toFixed(2)));
+                        dataUrl = canvas.toDataURL('image/jpeg', quality);
+                        byteSize = getUploadPayloadByteSize(dataUrl);
+                    }
+                }
+                resolve(dataUrl);
+            };
+            const originalBase64 = reader.result;
+            image.src = originalBase64;
+        };
+        reader.onerror = (event)=>{
+            reject(event);
+        };
+        reader.readAsDataURL(file);
+    });
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/utils/file.ts"],"sourcesContent":["const getUploadPayloadByteSize = (dataUrl: string): number => dataUrl.length;\n\nconst getFileNameWithoutExtension = (name: string): string => (\n  name.split('.').slice(0, -1).join('.') || name\n);\n\nconst createImageCanvas = (file: File, maxSize: number): Promise<{\n  canvas: HTMLCanvasElement;\n  context: CanvasRenderingContext2D;\n  height: number;\n  width: number;\n}> => new Promise((resolve, reject) => {\n  const image = new Image();\n  const objectUrl = URL.createObjectURL(file);\n\n  image.onload = () => {\n    URL.revokeObjectURL(objectUrl);\n\n    const canvas: HTMLCanvasElement = document.createElement('canvas');\n    const {height, width} = image;\n    let updatedHeight: number = height;\n    let updatedWidth: number = width;\n\n    if(width > height) {\n      if(width > maxSize) {\n        updatedHeight *= maxSize / width;\n        updatedWidth = maxSize;\n      }\n    } else if(height > maxSize) {\n      updatedWidth *= maxSize / height;\n      updatedHeight = maxSize;\n    }\n\n    const context = canvas.getContext('2d');\n\n    if(!context) {\n      reject(new Error('Unable to prepare image upload.'));\n      return;\n    }\n\n    resolve({\n      canvas,\n      context,\n      height: Math.max(1, Math.round(updatedHeight)),\n      width: Math.max(1, Math.round(updatedWidth))\n    });\n  };\n\n  image.onerror = () => {\n    URL.revokeObjectURL(objectUrl);\n    reject(new Error('Unable to prepare image upload.'));\n  };\n\n  image.src = objectUrl;\n});\n\nconst renderImageFile = (\n  canvas: HTMLCanvasElement,\n  context: CanvasRenderingContext2D,\n  image: CanvasImageSource,\n  width: number,\n  height: number,\n  quality: number,\n  name: string\n): Promise<File> => new Promise((resolve, reject) => {\n  canvas.width = width;\n  canvas.height = height;\n  context.clearRect(0, 0, width, height);\n  context.drawImage(image, 0, 0, width, height);\n\n  canvas.toBlob((blob) => {\n    if(!blob) {\n      reject(new Error('Unable to prepare image upload.'));\n      return;\n    }\n\n    resolve(new File([blob], `${getFileNameWithoutExtension(name)}.jpg`, {type: 'image/jpeg'}));\n  }, 'image/jpeg', quality);\n});\n\nexport const convertFileToUploadFile = async (\n  file: File,\n  maxSize: number,\n  maxBytes: number = 900 * 1024\n): Promise<File> => {\n  if(!file.type.startsWith('image/') || typeof document === 'undefined') {\n    return file;\n  }\n\n  const image = new Image();\n  const objectUrl = URL.createObjectURL(file);\n\n  try {\n    await new Promise<void>((resolve, reject) => {\n      image.onload = () => resolve();\n      image.onerror = () => reject(new Error('Unable to prepare image upload.'));\n      image.src = objectUrl;\n    });\n\n    const {canvas, context, height, width} = await createImageCanvas(file, maxSize);\n    let currentWidth = width;\n    let currentHeight = height;\n    let quality = 0.82;\n    let uploadFile = await renderImageFile(canvas, context, image, currentWidth, currentHeight, quality, file.name);\n\n    while(uploadFile.size > maxBytes && quality > 0.45) {\n      quality = Math.max(0.45, Number((quality - 0.08).toFixed(2)));\n      uploadFile = await renderImageFile(canvas, context, image, currentWidth, currentHeight, quality, file.name);\n    }\n\n    while(uploadFile.size > maxBytes && (currentWidth > 320 || currentHeight > 320)) {\n      currentWidth = Math.max(320, Math.round(currentWidth * 0.85));\n      currentHeight = Math.max(320, Math.round(currentHeight * 0.85));\n      quality = 0.78;\n      uploadFile = await renderImageFile(canvas, context, image, currentWidth, currentHeight, quality, file.name);\n\n      while(uploadFile.size > maxBytes && quality > 0.45) {\n        quality = Math.max(0.45, Number((quality - 0.08).toFixed(2)));\n        uploadFile = await renderImageFile(canvas, context, image, currentWidth, currentHeight, quality, file.name);\n      }\n    }\n\n    return uploadFile;\n  } finally {\n    URL.revokeObjectURL(objectUrl);\n  }\n};\n\nexport const convertFileToBase64 = (\n  file: File,\n  maxSize: number,\n  maxBytes: number = 900 * 1024\n): Promise<string> =>\n  new Promise((resolve, reject) => {\n    const reader = new FileReader();\n    reader.onload = () => {\n      const image = new Image();\n      image.onload = () => {\n        const canvas: HTMLCanvasElement = document.createElement('canvas');\n        const {height, width} = image;\n        let updatedHeight: number = height;\n        let updatedWidth: number = width;\n\n        if(width > height) {\n          if(width > maxSize) {\n            updatedHeight *= maxSize / width;\n            updatedWidth = maxSize;\n          }\n        } else if(height > maxSize) {\n          updatedWidth *= maxSize / height;\n          updatedHeight = maxSize;\n        }\n\n        const context = canvas.getContext('2d');\n\n        if(!context) {\n          reject(new Error('Unable to prepare image upload.'));\n          return;\n        }\n\n        const renderImage = (width: number, height: number) => {\n          canvas.width = width;\n          canvas.height = height;\n          context.clearRect(0, 0, width, height);\n          context.drawImage(image, 0, 0, width, height);\n        };\n\n        let currentWidth = Math.max(1, Math.round(updatedWidth));\n        let currentHeight = Math.max(1, Math.round(updatedHeight));\n        let quality = 0.82;\n\n        renderImage(currentWidth, currentHeight);\n\n        let dataUrl: string = canvas.toDataURL('image/jpeg', quality);\n        let byteSize = getUploadPayloadByteSize(dataUrl);\n\n        while(byteSize > maxBytes && quality > 0.45) {\n          quality = Math.max(0.45, Number((quality - 0.08).toFixed(2)));\n          dataUrl = canvas.toDataURL('image/jpeg', quality);\n          byteSize = getUploadPayloadByteSize(dataUrl);\n        }\n\n        while(byteSize > maxBytes && (currentWidth > 320 || currentHeight > 320)) {\n          currentWidth = Math.max(320, Math.round(currentWidth * 0.85));\n          currentHeight = Math.max(320, Math.round(currentHeight * 0.85));\n          quality = 0.78;\n          renderImage(currentWidth, currentHeight);\n          dataUrl = canvas.toDataURL('image/jpeg', quality);\n          byteSize = getUploadPayloadByteSize(dataUrl);\n\n          while(byteSize > maxBytes && quality > 0.45) {\n            quality = Math.max(0.45, Number((quality - 0.08).toFixed(2)));\n            dataUrl = canvas.toDataURL('image/jpeg', quality);\n            byteSize = getUploadPayloadByteSize(dataUrl);\n          }\n        }\n\n        resolve(dataUrl);\n      };\n\n      const originalBase64: string = reader.result as string;\n      image.src = originalBase64;\n    };\n    reader.onerror = (event: ProgressEvent) => {\n      reject(event);\n    };\n    reader.readAsDataURL(file);\n  });\n"],"names":["getUploadPayloadByteSize","dataUrl","length","getFileNameWithoutExtension","name","split","slice","join","createImageCanvas","file","maxSize","Promise","resolve","reject","image","Image","objectUrl","URL","createObjectURL","onload","revokeObjectURL","canvas","document","createElement","height","width","updatedHeight","updatedWidth","context","getContext","Error","Math","max","round","onerror","src","renderImageFile","quality","clearRect","drawImage","toBlob","blob","File","type","convertFileToUploadFile","maxBytes","startsWith","currentWidth","currentHeight","uploadFile","size","Number","toFixed","convertFileToBase64","reader","FileReader","renderImage","toDataURL","byteSize","originalBase64","result","event","readAsDataURL"],"mappings":"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"}

package/lib/utils/i18n.d.ts

@@ -0,0 +1,7 @@
+import type { ComplexTranslations, SimpleTranslations } from '../index.js';
+export declare const buildI18nResources: (translations: ComplexTranslations) => Record<string, Record<string, Record<string, string>>>;
+export declare const buildSimpleI18nResources: (translations: SimpleTranslations) => Record<string, Record<string, Record<string, string>>>;
+export declare const initI18n: (translations: SimpleTranslations | ComplexTranslations) => void;
+export declare const updateI18nResources: (translations: ComplexTranslations) => void;
+export declare const i18n: (key: string, params?: Record<string, any>, lng?: string, ns?: string) => string;
+//# sourceMappingURL=i18n.d.ts.map

package/lib/utils/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/utils/i18n.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAK3E,eAAO,MAAM,kBAAkB,GAC7B,cAAc,mBAAmB,2DAmBlC,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,cAAc,kBAAkB,2DAmBjC,CAAC;AAEF,eAAO,MAAM,QAAQ,GACnB,cAAc,kBAAkB,GAAG,mBAAmB,SAoCvD,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,cAAc,mBAAmB,SAelC,CAAC;AAEF,eAAO,MAAM,IAAI,GACf,KAAK,MAAM,EACX,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC5B,MAAM,MAAM,EACZ,KAAK,MAAM,KACV,MAUF,CAAC"}

package/lib/utils/i18n.js

@@ -0,0 +1,96 @@
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { init, t } from 'i18next';
+let initialized = false;
+let currentResources = {};
+export const buildI18nResources = (translations)=>{
+    const resources = {};
+    for(const key in translations){
+        const { locale, value, namespace } = translations[key];
+        const lang = locale || 'en';
+        const ns = namespace || 'translations';
+        if (!resources[lang]) {
+            resources[lang] = {};
+        }
+        if (!resources[lang][ns]) {
+            resources[lang][ns] = {};
+        }
+        resources[lang][ns][key] = value;
+    }
+    return resources;
+};
+export const buildSimpleI18nResources = (translations)=>{
+    const resources = {};
+    for(const key in translations){
+        const value = translations[key];
+        const lang = 'en'; // Default to English
+        const ns = 'translations'; // Default namespace
+        if (!resources[lang]) {
+            resources[lang] = {};
+        }
+        if (!resources[lang][ns]) {
+            resources[lang][ns] = {};
+        }
+        resources[lang][ns][key] = value;
+    }
+    return resources;
+};
+export const initI18n = (translations)=>{
+    if (initialized) {
+        return;
+    }
+    let resources = {};
+    // Check if it's a simple key-value format or complex format
+    if (translations && Object.keys(translations).length > 0) {
+        const firstKey = Object.keys(translations)[0];
+        const firstValue = translations[firstKey];
+        if (typeof firstValue === 'string') {
+            // Simple key-value format
+            resources = buildSimpleI18nResources(translations);
+        } else {
+            // Complex format with locale and namespace
+            resources = buildI18nResources(translations);
+        }
+    }
+    currentResources = resources;
+    const defaultLang = Object.keys(resources)[0] || 'en';
+    const namespaces = Object.keys(resources[defaultLang] || {});
+    init({
+        defaultNS: 'translations',
+        fallbackLng: defaultLang,
+        interpolation: {
+            escapeValue: false
+        },
+        lng: defaultLang,
+        ns: namespaces,
+        resources
+    });
+    initialized = true;
+};
+export const updateI18nResources = (translations)=>{
+    const newResources = buildI18nResources(translations);
+    Object.entries(newResources).forEach(([lng, namespaces])=>{
+        Object.entries(namespaces).forEach(([ns, keys])=>{
+            if (!currentResources[lng]) {
+                currentResources[lng] = {};
+            }
+            if (!currentResources[lng][ns]) {
+                currentResources[lng][ns] = {};
+            }
+            Object.assign(currentResources[lng][ns], keys);
+        });
+    });
+};
+export const i18n = (key, params, lng, ns)=>{
+    if (!initialized) {
+        return key;
+    }
+    return t(key, {
+        ...params || {},
+        lng,
+        ns: ns || 'translations'
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/utils/i18n.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport { init, t } from 'i18next';\n\n// Import types from the main index\nimport type { ComplexTranslations, SimpleTranslations } from '../index.js';\n\nlet initialized = false;\nlet currentResources: Record<string, Record<string, Record<string, string>>> = {};\n\nexport const buildI18nResources = (\n  translations: ComplexTranslations\n) => {\n  const resources: Record<string, Record<string, Record<string, string>>> = {};\n\n  for(const key in translations) {\n    const {locale, value, namespace} = translations[key];\n    const lang = locale || 'en';\n    const ns = namespace || 'translations';\n\n    if(!resources[lang]) {\n      resources[lang] = {};\n    }\n    if(!resources[lang][ns]) {\n      resources[lang][ns] = {};\n    }\n    resources[lang][ns][key] = value;\n  }\n\n  return resources;\n};\n\nexport const buildSimpleI18nResources = (\n  translations: SimpleTranslations\n) => {\n  const resources: Record<string, Record<string, Record<string, string>>> = {};\n\n  for(const key in translations) {\n    const value = translations[key];\n    const lang = 'en'; // Default to English\n    const ns = 'translations'; // Default namespace\n\n    if(!resources[lang]) {\n      resources[lang] = {};\n    }\n    if(!resources[lang][ns]) {\n      resources[lang][ns] = {};\n    }\n    resources[lang][ns][key] = value;\n  }\n\n  return resources;\n};\n\nexport const initI18n = (\n  translations: SimpleTranslations | ComplexTranslations\n) => {\n  if(initialized) {\n    return;\n  }\n\n  let resources: Record<string, Record<string, Record<string, string>>> = {};\n\n  // Check if it's a simple key-value format or complex format\n  if (translations && Object.keys(translations).length > 0) {\n    const firstKey = Object.keys(translations)[0];\n    const firstValue = translations[firstKey];\n\n    if (typeof firstValue === 'string') {\n      // Simple key-value format\n      resources = buildSimpleI18nResources(translations as SimpleTranslations);\n    } else {\n      // Complex format with locale and namespace\n      resources = buildI18nResources(translations as ComplexTranslations);\n    }\n  }\n\n  currentResources = resources;\n  const defaultLang = Object.keys(resources)[0] || 'en';\n  const namespaces = Object.keys(resources[defaultLang] || {});\n\n  init({\n    defaultNS: 'translations',\n    fallbackLng: defaultLang,\n    interpolation: {escapeValue: false},\n    lng: defaultLang,\n    ns: namespaces,\n    resources\n  });\n\n  initialized = true;\n};\n\nexport const updateI18nResources = (\n  translations: ComplexTranslations\n) => {\n  const newResources = buildI18nResources(translations);\n\n  Object.entries(newResources).forEach(([lng, namespaces]) => {\n    Object.entries(namespaces).forEach(([ns, keys]) => {\n      if(!currentResources[lng]) {\n        currentResources[lng] = {};\n      }\n      if(!currentResources[lng][ns]) {\n        currentResources[lng][ns] = {};\n      }\n      Object.assign(currentResources[lng][ns], keys);\n    });\n  });\n};\n\nexport const i18n = (\n  key: string,\n  params?: Record<string, any>,\n  lng?: string,\n  ns?: string\n): string => {\n  if(!initialized) {\n    return key;\n  }\n\n  return t(key, {\n    ...(params || {}),\n    lng,\n    ns: ns || 'translations'\n  });\n};"],"names":["init","t","initialized","currentResources","buildI18nResources","translations","resources","key","locale","value","namespace","lang","ns","buildSimpleI18nResources","initI18n","Object","keys","length","firstKey","firstValue","defaultLang","namespaces","defaultNS","fallbackLng","interpolation","escapeValue","lng","updateI18nResources","newResources","entries","forEach","assign","i18n","params"],"mappings":"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"}

package/lib/utils/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+export { appMutation, appQuery, getGraphql, publicMutation, publicQuery, refreshSession, uploadImage, type ApiResultsType, type ReaktorDbCollection, type SessionType } from './api.js';
+export { createAction, createActions, createAllActions, type ActionOptions, type ActionReturnType, type ActionType, type ActionTypes } from './actionFactory.js';
+export { createBaseActions, type BaseActionOptions } from './baseActionFactory.js';
+export { createValidatorFactory, createValidatorManager, type BaseAdapterOptions } from './validatorFactory.js';
+export { MetropolisContext, MetropolisProvider } from './MetropolisProvider.js';
+export { PermissionGuard, PermissionLevel, usePermissions, type Permission, type PermissionGuardProps, type UsePermissionsReturn } from './permissionUtils.js';
+export { useMetropolis } from './useMetropolis.js';
+export { useConversationTyping, type ConversationTypingOptions, type UseConversationTypingOptions } from './useConversationTyping.js';
+export { useTranslations } from './useTranslations.js';
+export * from './app.js';
+export * from './dateUtils.js';
+export * from './file.js';
+export * from './i18n.js';
+export * from './location.js';
+export * from './session.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,WAAW,EACX,QAAQ,EACR,UAAU,EACV,cAAc,EACd,WAAW,EACX,cAAc,EACd,WAAW,EACX,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,WAAW,EACjB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,UAAU,EACf,KAAK,WAAW,EACjB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,iBAAiB,EACjB,KAAK,iBAAiB,EACvB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,KAAK,kBAAkB,EACxB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAC,iBAAiB,EAAE,kBAAkB,EAAC,MAAM,yBAAyB,CAAC;AAC9E,OAAO,EACL,eAAe,EACf,eAAe,EACf,cAAc,EACd,KAAK,UAAU,EACf,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAC,qBAAqB,EAAE,KAAK,yBAAyB,EAAE,KAAK,4BAA4B,EAAC,MAAM,4BAA4B,CAAC;AACpI,OAAO,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAGrD,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC"}

package/lib/utils/index.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ // Export API utilities
+export { appMutation, appQuery, getGraphql, publicMutation, publicQuery, refreshSession, uploadImage } from './api.js';
+// Export action factory
+export { createAction, createActions, createAllActions } from './actionFactory.js';
+// Export base action factory
+export { createBaseActions } from './baseActionFactory.js';
+// Export validator factory
+export { createValidatorFactory, createValidatorManager } from './validatorFactory.js';
+// Export React hooks
+export { MetropolisContext, MetropolisProvider } from './MetropolisProvider.js';
+export { PermissionGuard, PermissionLevel, usePermissions } from './permissionUtils.js';
+export { useMetropolis } from './useMetropolis.js';
+export { useConversationTyping } from './useConversationTyping.js';
+export { useTranslations } from './useTranslations.js';
+// Export utility functions
+export * from './app.js';
+export * from './dateUtils.js';
+export * from './file.js';
+export * from './i18n.js';
+export * from './location.js';
+export * from './session.js';
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/location.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) 2012-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import { FluxFramework } from '@nlabs/arkhamjs';
+import { parseLocation } from '../adapters/locationAdapter/locationAdapter.js';
+import type { LocationType } from '../adapters/locationAdapter/locationAdapter.js';
+export declare const autoCompleteLocation: (this: unknown, flux: FluxFramework, address: string, latitude?: number, longitude?: number, locationProps?: string[], CustomClass?: (location: LocationType) => LocationType) => Promise<LocationType[]>;
+export declare const searchLocations: (flux: FluxFramework, address: string, latitude?: number, longitude?: number, locationProps?: string[], CustomClass?: typeof parseLocation) => Promise<LocationType[]>;
+//# sourceMappingURL=location.d.ts.map

package/lib/utils/location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"location.d.ts","sourceRoot":"","sources":["../../src/utils/location.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIhD,OAAO,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AAG/E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gDAAgD,CAAC;AAKnF,eAAO,MAAM,oBAAoB,2MA4C1B,CAAC;AAER,eAAO,MAAM,eAAe,GAC1B,MAAM,aAAa,EACnB,SAAS,MAAM,EACf,WAAW,MAAM,EACjB,YAAY,MAAM,EAClB,gBAAe,MAAM,EAAO,EAC5B,cAAa,OAAO,aAA6B,KAChD,OAAO,CAAC,YAAY,EAAE,CAqCxB,CAAC"}

package/lib/utils/location.js

@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2012-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { isEmpty } from '@nlabs/utils';
+import pDebounce from 'p-debounce';
+import { parseLocation } from '../adapters/locationAdapter/locationAdapter.js';
+import { appQuery } from '../utils/api.js';
+const DATA_TYPE = 'locations';
+export const autoCompleteLocation = pDebounce(async (flux, address, latitude, longitude, locationProps = [], CustomClass = parseLocation)=>{
+    if (isEmpty(address)) {
+        return [];
+    }
+    try {
+        const queryVariables = {
+            address: {
+                type: 'String',
+                value: address
+            },
+            latitude: {
+                type: 'Float',
+                value: latitude
+            },
+            longitude: {
+                type: 'Float',
+                value: longitude
+            }
+        };
+        const { autoCompleteLocation = [] } = await appQuery(flux, 'autoCompleteLocation', DATA_TYPE, queryVariables, [
+            'address',
+            'city',
+            'country',
+            'latitude',
+            'location',
+            'longitude',
+            'state',
+            'street',
+            'zip',
+            ...locationProps
+        ]);
+        return autoCompleteLocation.map((item)=>CustomClass(item));
+    } catch (_error) {
+        return [];
+    }
+}, 500);
+export const searchLocations = async (flux, address, latitude, longitude, locationProps = [], CustomClass = parseLocation)=>{
+    if (isEmpty(address)) {
+        return [];
+    }
+    try {
+        const queryVariables = {
+            address: {
+                type: 'String',
+                value: address
+            },
+            latitude: {
+                type: 'Float',
+                value: latitude
+            },
+            longitude: {
+                type: 'Float',
+                value: longitude
+            }
+        };
+        const { autoCompleteLocation = [] } = await appQuery(flux, 'autoCompleteLocation', DATA_TYPE, queryVariables, [
+            'address',
+            'city',
+            'country',
+            'latitude',
+            'location',
+            'longitude',
+            'state',
+            'street',
+            'zip',
+            ...locationProps
+        ]);
+        return autoCompleteLocation.map((item)=>CustomClass(item));
+    } catch (_error) {
+        return [];
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L21ldHJvcG9saXNqcy9zcmMvdXRpbHMvbG9jYXRpb24udHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTItUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cbmltcG9ydCB7IEZsdXhGcmFtZXdvcmsgfSBmcm9tICdAbmxhYnMvYXJraGFtanMnO1xuaW1wb3J0IHsgaXNFbXB0eSB9IGZyb20gJ0BubGFicy91dGlscyc7XG5pbXBvcnQgcERlYm91bmNlIGZyb20gJ3AtZGVib3VuY2UnO1xuXG5pbXBvcnQgeyBwYXJzZUxvY2F0aW9uIH0gZnJvbSAnLi4vYWRhcHRlcnMvbG9jYXRpb25BZGFwdGVyL2xvY2F0aW9uQWRhcHRlci5qcyc7XG5pbXBvcnQgeyBhcHBRdWVyeSB9IGZyb20gJy4uL3V0aWxzL2FwaS5qcyc7XG5cbmltcG9ydCB0eXBlIHsgTG9jYXRpb25UeXBlIH0gZnJvbSAnLi4vYWRhcHRlcnMvbG9jYXRpb25BZGFwdGVyL2xvY2F0aW9uQWRhcHRlci5qcyc7XG5pbXBvcnQgdHlwZSB7IFJlYWt0b3JEYkNvbGxlY3Rpb24gfSBmcm9tICcuLi91dGlscy9hcGkuanMnO1xuXG5jb25zdCBEQVRBX1RZUEU6IFJlYWt0b3JEYkNvbGxlY3Rpb24gPSAnbG9jYXRpb25zJztcblxuZXhwb3J0IGNvbnN0IGF1dG9Db21wbGV0ZUxvY2F0aW9uID0gcERlYm91bmNlKGFzeW5jIChcbiAgZmx1eDogRmx1eEZyYW1ld29yayxcbiAgYWRkcmVzczogc3RyaW5nLFxuICBsYXRpdHVkZT86IG51bWJlcixcbiAgbG9uZ2l0dWRlPzogbnVtYmVyLFxuICBsb2NhdGlvblByb3BzOiBzdHJpbmdbXSA9IFtdLFxuICBDdXN0b21DbGFzczogdHlwZW9mIHBhcnNlTG9jYXRpb24gPSBwYXJzZUxvY2F0aW9uXG4pOiBQcm9taXNlPExvY2F0aW9uVHlwZVtdPiA9PiB7XG4gIGlmKGlzRW1wdHkoYWRkcmVzcykpIHtcbiAgICByZXR1cm4gW107XG4gIH1cblxuICB0cnkge1xuICAgIGNvbnN0IHF1ZXJ5VmFyaWFibGVzID0ge1xuICAgICAgYWRkcmVzczoge1xuICAgICAgICB0eXBlOiAnU3RyaW5nJyxcbiAgICAgICAgdmFsdWU6IGFkZHJlc3NcbiAgICAgIH0sXG4gICAgICBsYXRpdHVkZToge1xuICAgICAgICB0eXBlOiAnRmxvYXQnLFxuICAgICAgICB2YWx1ZTogbGF0aXR1ZGVcbiAgICAgIH0sXG4gICAgICBsb25naXR1ZGU6IHtcbiAgICAgICAgdHlwZTogJ0Zsb2F0JyxcbiAgICAgICAgdmFsdWU6IGxvbmdpdHVkZVxuICAgICAgfVxuICAgIH07XG5cbiAgICBjb25zdCB7YXV0b0NvbXBsZXRlTG9jYXRpb24gPSBbXX0gPSBhd2FpdCBhcHBRdWVyeShmbHV4LCAnYXV0b0NvbXBsZXRlTG9jYXRpb24nLCBEQVRBX1RZUEUsIHF1ZXJ5VmFyaWFibGVzLCBbXG4gICAgICAnYWRkcmVzcycsXG4gICAgICAnY2l0eScsXG4gICAgICAnY291bnRyeScsXG4gICAgICAnbGF0aXR1ZGUnLFxuICAgICAgJ2xvY2F0aW9uJyxcbiAgICAgICdsb25naXR1ZGUnLFxuICAgICAgJ3N0YXRlJyxcbiAgICAgICdzdHJlZXQnLFxuICAgICAgJ3ppcCcsXG4gICAgICAuLi5sb2NhdGlvblByb3BzXG4gICAgXSkgYXMge2F1dG9Db21wbGV0ZUxvY2F0aW9uOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPltdfTtcbiAgICByZXR1cm4gYXV0b0NvbXBsZXRlTG9jYXRpb24ubWFwKChpdGVtKSA9PiBDdXN0b21DbGFzcyhpdGVtKSk7XG4gIH0gY2F0Y2goX2Vycm9yKSB7XG4gICAgcmV0dXJuIFtdO1xuICB9XG59LCA1MDApO1xuXG5leHBvcnQgY29uc3Qgc2VhcmNoTG9jYXRpb25zID0gYXN5bmMgKFxuICBmbHV4OiBGbHV4RnJhbWV3b3JrLFxuICBhZGRyZXNzOiBzdHJpbmcsXG4gIGxhdGl0dWRlPzogbnVtYmVyLFxuICBsb25naXR1ZGU/OiBudW1iZXIsXG4gIGxvY2F0aW9uUHJvcHM6IHN0cmluZ1tdID0gW10sXG4gIEN1c3RvbUNsYXNzOiB0eXBlb2YgcGFyc2VMb2NhdGlvbiA9IHBhcnNlTG9jYXRpb25cbik6IFByb21pc2U8TG9jYXRpb25UeXBlW10+ID0+IHtcbiAgaWYoaXNFbXB0eShhZGRyZXNzKSkge1xuICAgIHJldHVybiBbXTtcbiAgfVxuXG4gIHRyeSB7XG4gICAgY29uc3QgcXVlcnlWYXJpYWJsZXMgPSB7XG4gICAgICBhZGRyZXNzOiB7XG4gICAgICAgIHR5cGU6ICdTdHJpbmcnLFxuICAgICAgICB2YWx1ZTogYWRkcmVzc1xuICAgICAgfSxcbiAgICAgIGxhdGl0dWRlOiB7XG4gICAgICAgIHR5cGU6ICdGbG9hdCcsXG4gICAgICAgIHZhbHVlOiBsYXRpdHVkZVxuICAgICAgfSxcbiAgICAgIGxvbmdpdHVkZToge1xuICAgICAgICB0eXBlOiAnRmxvYXQnLFxuICAgICAgICB2YWx1ZTogbG9uZ2l0dWRlXG4gICAgICB9XG4gICAgfTtcblxuICAgIGNvbnN0IHthdXRvQ29tcGxldGVMb2NhdGlvbiA9IFtdfSA9IGF3YWl0IGFwcFF1ZXJ5KGZsdXgsICdhdXRvQ29tcGxldGVMb2NhdGlvbicsIERBVEFfVFlQRSwgcXVlcnlWYXJpYWJsZXMsIFtcbiAgICAgICdhZGRyZXNzJyxcbiAgICAgICdjaXR5JyxcbiAgICAgICdjb3VudHJ5JyxcbiAgICAgICdsYXRpdHVkZScsXG4gICAgICAnbG9jYXRpb24nLFxuICAgICAgJ2xvbmdpdHVkZScsXG4gICAgICAnc3RhdGUnLFxuICAgICAgJ3N0cmVldCcsXG4gICAgICAnemlwJyxcbiAgICAgIC4uLmxvY2F0aW9uUHJvcHNcbiAgICBdKSBhcyB7YXV0b0NvbXBsZXRlTG9jYXRpb246IFJlY29yZDxzdHJpbmcsIHVua25vd24+W119O1xuICAgIHJldHVybiBhdXRvQ29tcGxldGVMb2NhdGlvbi5tYXAoKGl0ZW0pID0+IEN1c3RvbUNsYXNzKGl0ZW0pKTtcbiAgfSBjYXRjaChfZXJyb3IpIHtcbiAgICByZXR1cm4gW107XG4gIH1cbn07XG4iXSwibmFtZXMiOlsiaXNFbXB0eSIsInBEZWJvdW5jZSIsInBhcnNlTG9jYXRpb24iLCJhcHBRdWVyeSIsIkRBVEFfVFlQRSIsImF1dG9Db21wbGV0ZUxvY2F0aW9uIiwiZmx1eCIsImFkZHJlc3MiLCJsYXRpdHVkZSIsImxvbmdpdHVkZSIsImxvY2F0aW9uUHJvcHMiLCJDdXN0b21DbGFzcyIsInF1ZXJ5VmFyaWFibGVzIiwidHlwZSIsInZhbHVlIiwibWFwIiwiaXRlbSIsIl9lcnJvciIsInNlYXJjaExvY2F0aW9ucyJdLCJtYXBwaW5ncyI6IkFBQUE7OztDQUdDLEdBRUQsU0FBU0EsT0FBTyxRQUFRLGVBQWU7QUFDdkMsT0FBT0MsZUFBZSxhQUFhO0FBRW5DLFNBQVNDLGFBQWEsUUFBUSxpREFBaUQ7QUFDL0UsU0FBU0MsUUFBUSxRQUFRLGtCQUFrQjtBQUszQyxNQUFNQyxZQUFpQztBQUV2QyxPQUFPLE1BQU1DLHVCQUF1QkosVUFBVSxPQUM1Q0ssTUFDQUMsU0FDQUMsVUFDQUMsV0FDQUMsZ0JBQTBCLEVBQUUsRUFDNUJDLGNBQW9DVCxhQUFhO0lBRWpELElBQUdGLFFBQVFPLFVBQVU7UUFDbkIsT0FBTyxFQUFFO0lBQ1g7SUFFQSxJQUFJO1FBQ0YsTUFBTUssaUJBQWlCO1lBQ3JCTCxTQUFTO2dCQUNQTSxNQUFNO2dCQUNOQyxPQUFPUDtZQUNUO1lBQ0FDLFVBQVU7Z0JBQ1JLLE1BQU07Z0JBQ05DLE9BQU9OO1lBQ1Q7WUFDQUMsV0FBVztnQkFDVEksTUFBTTtnQkFDTkMsT0FBT0w7WUFDVDtRQUNGO1FBRUEsTUFBTSxFQUFDSix1QkFBdUIsRUFBRSxFQUFDLEdBQUcsTUFBTUYsU0FBU0csTUFBTSx3QkFBd0JGLFdBQVdRLGdCQUFnQjtZQUMxRztZQUNBO1lBQ0E7WUFDQTtZQUNBO1lBQ0E7WUFDQTtZQUNBO1lBQ0E7ZUFDR0Y7U0FDSjtRQUNELE9BQU9MLHFCQUFxQlUsR0FBRyxDQUFDLENBQUNDLE9BQVNMLFlBQVlLO0lBQ3hELEVBQUUsT0FBTUMsUUFBUTtRQUNkLE9BQU8sRUFBRTtJQUNYO0FBQ0YsR0FBRyxLQUFLO0FBRVIsT0FBTyxNQUFNQyxrQkFBa0IsT0FDN0JaLE1BQ0FDLFNBQ0FDLFVBQ0FDLFdBQ0FDLGdCQUEwQixFQUFFLEVBQzVCQyxjQUFvQ1QsYUFBYTtJQUVqRCxJQUFHRixRQUFRTyxVQUFVO1FBQ25CLE9BQU8sRUFBRTtJQUNYO0lBRUEsSUFBSTtRQUNGLE1BQU1LLGlCQUFpQjtZQUNyQkwsU0FBUztnQkFDUE0sTUFBTTtnQkFDTkMsT0FBT1A7WUFDVDtZQUNBQyxVQUFVO2dCQUNSSyxNQUFNO2dCQUNOQyxPQUFPTjtZQUNUO1lBQ0FDLFdBQVc7Z0JBQ1RJLE1BQU07Z0JBQ05DLE9BQU9MO1lBQ1Q7UUFDRjtRQUVBLE1BQU0sRUFBQ0osdUJBQXVCLEVBQUUsRUFBQyxHQUFHLE1BQU1GLFNBQVNHLE1BQU0sd0JBQXdCRixXQUFXUSxnQkFBZ0I7WUFDMUc7WUFDQTtZQUNBO1lBQ0E7WUFDQTtZQUNBO1lBQ0E7WUFDQTtZQUNBO2VBQ0dGO1NBQ0o7UUFDRCxPQUFPTCxxQkFBcUJVLEdBQUcsQ0FBQyxDQUFDQyxPQUFTTCxZQUFZSztJQUN4RCxFQUFFLE9BQU1DLFFBQVE7UUFDZCxPQUFPLEVBQUU7SUFDWDtBQUNGLEVBQUUifQ==

package/lib/utils/permissionUtils.d.ts

@@ -0,0 +1,22 @@
+import { PermissionLevel } from '../adapters/permissionAdapter/permissionAdapter.js';
+export interface PermissionGuardProps {
+    requiredLevel: PermissionLevel;
+    resource?: string;
+    fallback?: React.ReactNode;
+    children: React.ReactNode;
+}
+export interface UsePermissionsReturn {
+    userLevel: number;
+    hasPermission: (requiredLevel: PermissionLevel) => boolean;
+    isGuest: boolean;
+    isUser: boolean;
+    isModerator: boolean;
+    isAdmin: boolean;
+    isSuperAdmin: boolean;
+    checkResource: (resource: string, requiredLevel: PermissionLevel) => boolean;
+}
+export declare const usePermissions: () => UsePermissionsReturn;
+export declare const PermissionGuard: React.FC<PermissionGuardProps>;
+export { PermissionLevel } from '../adapters/permissionAdapter/permissionAdapter.js';
+export type { Permission } from '../adapters/permissionAdapter/permissionAdapter.js';
+//# sourceMappingURL=permissionUtils.d.ts.map

package/lib/utils/permissionUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissionUtils.d.ts","sourceRoot":"","sources":["../../src/utils/permissionUtils.tsx"],"names":[],"mappings":"AAOA,OAAO,EAOL,eAAe,EAChB,MAAM,oDAAoD,CAAC;AAI5D,MAAM,WAAW,oBAAoB;IACnC,aAAa,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,CAAC,aAAa,EAAE,eAAe,KAAK,OAAO,CAAC;IAC3D,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,eAAe,KAAK,OAAO,CAAC;CAC9E;AAED,eAAO,MAAM,cAAc,QAAO,oBAyDjC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAiB1D,CAAC;AAEF,OAAO,EAAC,eAAe,EAAC,MAAM,oDAAoD,CAAC;AACnF,YAAY,EAAC,UAAU,EAAC,MAAM,oDAAoD,CAAC"}