@contentstorage/core 0.3.31 → 0.3.33

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { AppConfig, LanguageCode, ContentStructure } from './types.js';
-import { setContentLanguage, getText, getImage, getVariation } from './lib/contentManagement.js';
+import { setContentLanguage, getText, getImage, getVariation, initContentStorage } from './lib/contentManagement.js';
+import { fetchContent } from './lib/functions/fetchContent.js';
 export { AppConfig, LanguageCode, ContentStructure };
-export { setContentLanguage, getText, getImage, getVariation };
+export { initContentStorage, fetchContent, setContentLanguage, getText, getImage, getVariation, };

package/dist/index.js

@@ -1,2 +1,50 @@
-import { setContentLanguage, getText, getImage, getVariation, } from './lib/contentManagement.js';
-export { setContentLanguage, getText, getImage, getVariation };
+import { setContentLanguage, getText, getImage, getVariation, initContentStorage, } from './lib/contentManagement.js';
+import { fetchContent } from './lib/functions/fetchContent.js';
+export { initContentStorage, fetchContent, setContentLanguage, getText, getImage, getVariation, };
+async function isLiveEditorMode() {
+    try {
+        const inIframe = window.self !== window.top;
+        const urlParams = new URLSearchParams(window.location.search);
+        const iframeMarkerFromParent = urlParams.get('contentstorage_live_editor');
+        return !!(inIframe && iframeMarkerFromParent);
+    }
+    catch (e) {
+        // This catch block is for rare edge cases or highly sandboxed environments
+        // where accessing window.top might throw an error.
+        // If an error occurs, it's safer to assume it might be in an iframe.
+        console.warn('Error accessing window.top, assuming iframe context:', e);
+        return false;
+    }
+}
+isLiveEditorMode().then(async (isLiveMode) => {
+    if (!isLiveMode) {
+        return;
+    }
+    const cdnScriptUrl = `https://your-cdn-domain.com/contentstorage-live-editor.js?contentstorage-live-editor=true`;
+    return new Promise((resolve, reject) => {
+        console.log(`Attempting to load script from: ${cdnScriptUrl}`);
+        // 1. Create a new <script> element
+        const scriptElement = document.createElement('script');
+        scriptElement.type = 'text/javascript';
+        // 2. Set the src attribute to your script's URL
+        // The browser will fetch and execute it.
+        scriptElement.src = cdnScriptUrl;
+        // 3. Handle successful loading
+        scriptElement.onload = () => {
+            console.log(`Script loaded successfully from: ${cdnScriptUrl}`);
+            // The script has been fetched and executed by the browser.
+            // If it's an IIFE, it has already run.
+            resolve(true); // Resolve the promise indicating success
+        };
+        // 4. Handle errors during loading (e.g., network error, 404)
+        scriptElement.onerror = (error) => {
+            console.error(`Failed to load script from: ${cdnScriptUrl}`, error);
+            reject(new Error(`Failed to load script: ${cdnScriptUrl}`)); // Reject the promise
+        };
+        // 5. Append the script element to the document's head (or body)
+        // This triggers the browser to start loading the script.
+        document.head.appendChild(scriptElement);
+        // Or: document.body.appendChild(scriptElement);
+    });
+    // fetch script to handle iframe communication
+});

package/dist/lib/contentManagement.d.ts

@@ -1,25 +1,27 @@
-import { ContentStructure, ImageObject } from '../types.js';
+import { AppConfig, ContentStructure, GetImageReturn, GetTextReturn, GetVariationReturn } from '../types.js';
+export declare let activeContent: object | null;
+export declare let appConfig: AppConfig | null;
 /**
  * Loads and sets the content for a specific language.
  * It will internally ensure the application configuration (for contentDir) is loaded.
  * @param contentJson
  */
 export declare function setContentLanguage(contentJson: object): void;
+export declare function initContentStorage(config: AppConfig): void;
 /**
  * Retrieves the text string from the loaded JSON content for the given path.
  * Autocompletion for pathString is enabled via module augmentation of CustomContentStructure.
  * `setContentLanguage()` must be called successfully before using this.
  *
- * @param pathString A dot-notation path string (e.g., 'HomePage.Login'). Autocompletion is provided.
+ * @param contentKey A dot-notation path string (e.g., 'HomePage.Login'). Autocompletion is provided.
  * @param variables Variables help to render dynamic content inside text strings
- * @param fallbackValue Optional string to return if the path is not found or the value is not a string.
  * If not provided, and path is not found/value not string, undefined is returned.
  * @returns The text string from the JSON, or the fallbackValue, or undefined.
  */
-export declare function getText<Path extends keyof ContentStructure>(pathString: Path, variables?: ContentStructure[Path] extends {
+export declare function getText<Path extends keyof ContentStructure>(contentKey: Path, variables?: ContentStructure[Path] extends {
     variables: infer Vars;
-} ? keyof Vars : Record<string, any>): string | undefined;
-export declare function getImage(pathString: keyof ContentStructure, fallbackValue?: ImageObject): ImageObject | undefined;
-export declare function getVariation<Path extends keyof ContentStructure>(pathString: Path, variationKey?: ContentStructure[Path] extends {
+} ? keyof Vars : Record<string, any>): GetTextReturn | '';
+export declare function getImage(contentKey: keyof ContentStructure): GetImageReturn | undefined;
+export declare function getVariation<Path extends keyof ContentStructure>(contentKey: Path, variationKey?: ContentStructure[Path] extends {
     data: infer D;
-} ? keyof D : string, variables?: Record<string, any>): string | undefined;
+} ? keyof D : string, variables?: Record<string, any>): GetVariationReturn;

package/dist/lib/contentManagement.js

@@ -1,5 +1,6 @@
 import { populateTextWithVariables } from '../helpers/populateTextWithVariables.js';
-let activeContent = null;
+export let activeContent = null;
+export let appConfig = null;
 /**
  * Loads and sets the content for a specific language.
  * It will internally ensure the application configuration (for contentDir) is loaded.
@@ -18,94 +19,127 @@ export function setContentLanguage(contentJson) {
         console.error(`[Contentstorage] Failed to load content. Error: ${error.message}`);
     }
 }
+export function initContentStorage(config) {
+    if (!config ||
+        typeof config !== 'object' ||
+        !config.contentKey ||
+        !Array.isArray(config.languageCodes)) {
+        if (!config.contentKey) {
+            throw new Error('[Contentstorage] No contentKey provided in initContentStorage function.');
+        }
+        if (!Array.isArray(config.languageCodes)) {
+            throw new Error('[Contentstorage] No languageCodes provided in initContentStorage function.');
+        }
+        throw new Error('[Contentstorage] Invalid config.');
+    }
+    appConfig = config;
+}
 /**
  * Retrieves the text string from the loaded JSON content for the given path.
  * Autocompletion for pathString is enabled via module augmentation of CustomContentStructure.
  * `setContentLanguage()` must be called successfully before using this.
  *
- * @param pathString A dot-notation path string (e.g., 'HomePage.Login'). Autocompletion is provided.
+ * @param contentKey A dot-notation path string (e.g., 'HomePage.Login'). Autocompletion is provided.
  * @param variables Variables help to render dynamic content inside text strings
- * @param fallbackValue Optional string to return if the path is not found or the value is not a string.
  * If not provided, and path is not found/value not string, undefined is returned.
  * @returns The text string from the JSON, or the fallbackValue, or undefined.
  */
-export function getText(pathString, variables) {
+export function getText(contentKey, variables) {
     if (!activeContent) {
-        const msg = `[Contentstorage] getText: Content not loaded (Key: "${String(pathString)}"). Ensure setContentLanguage() was called and completed successfully.`;
+        const msg = `[Contentstorage] getText: Content not loaded (Key: "${String(contentKey)}"). Ensure setContentLanguage() was called and completed successfully.`;
         console.warn(msg);
         return '';
     }
-    const keys = pathString.split('.');
+    const keys = contentKey.split('.');
     let current = activeContent;
     for (const key of keys) {
         if (current && typeof current === 'object' && key in current) {
             current = current[key];
         }
         else {
-            const msg = `[Contentstorage] getText: Path "${String(pathString)}" not found in loaded content.`;
+            const msg = `[Contentstorage] getText: Path "${String(contentKey)}" not found in loaded content.`;
             console.warn(msg);
             return '';
         }
     }
     if (typeof current === 'string') {
         if (!variables || Object.keys(variables).length === 0) {
-            return current;
+            return {
+                contentKey,
+                text: current,
+            };
         }
-        return populateTextWithVariables(current, variables, pathString);
+        return {
+            contentKey,
+            text: populateTextWithVariables(current, variables, contentKey),
+        };
     }
     else {
-        const msg = `[Contentstorage] getText: Value at path "${String(pathString)}" is not a string (actual type: ${typeof current}).`;
+        const msg = `[Contentstorage] getText: Value at path "${String(contentKey)}" is not a string (actual type: ${typeof current}).`;
         console.warn(msg);
         return '';
     }
 }
-export function getImage(pathString, fallbackValue) {
+export function getImage(contentKey) {
+    const defaultVal = {
+        contentKey,
+        data: { url: '', altText: '', contentstorage_type: 'image' },
+    };
     if (!activeContent) {
-        const msg = `[Contentstorage] getImage: Content not loaded (Key: "${pathString}"). Ensure setContentLanguage() was called and completed successfully.`;
+        const msg = `[Contentstorage] getImage: Content not loaded (Key: "${contentKey}"). Ensure setContentLanguage() was called and completed successfully.`;
         console.warn(msg);
-        return fallbackValue;
+        return {
+            contentKey,
+            data: { url: '', altText: '', contentstorage_type: 'image' },
+        };
     }
-    const keys = pathString.split('.');
+    const keys = contentKey.split('.');
     let current = activeContent;
     for (const key of keys) {
         if (current && typeof current === 'object' && key in current) {
             current = current[key];
         }
         else {
-            const msg = `[Contentstorage] getImage: Path "${pathString}" not found in loaded content.`;
+            const msg = `[Contentstorage] getImage: Path "${contentKey}" not found in loaded content.`;
             console.warn(msg);
-            return fallbackValue;
+            return defaultVal;
         }
     }
     if (current &&
         typeof current === 'object' &&
         current.contentstorage_type === 'image' &&
-        typeof current.url === 'string' &&
-        typeof current.altText === 'string') {
-        return current;
+        typeof current.url === 'string') {
+        return {
+            contentKey,
+            data: current,
+        };
     }
     else {
-        const msg = `[Contentstorage] getImage: Value at path "${pathString}" is not a valid image object (actual value: ${JSON.stringify(current)}).`;
+        const msg = `[Contentstorage] getImage: Value at path "${contentKey}" is not a valid image object (actual value: ${JSON.stringify(current)}).`;
         console.warn(msg);
-        return fallbackValue;
+        return defaultVal;
     }
 }
-export function getVariation(pathString, variationKey, variables) {
+export function getVariation(contentKey, variationKey, variables) {
+    const defaultVal = {
+        contentKey,
+        text: '',
+    };
     if (!activeContent) {
-        const msg = `[Contentstorage] getVariation: Content not loaded (Key: "${pathString}", Variation: "${variationKey?.toString()}"). Ensure setContentLanguage() was called and completed successfully.`;
+        const msg = `[Contentstorage] getVariation: Content not loaded (Key: "${contentKey}", Variation: "${variationKey?.toString()}"). Ensure setContentLanguage() was called and completed successfully.`;
         console.warn(msg);
-        return '';
+        return defaultVal;
     }
-    const keys = pathString.split('.');
+    const keys = contentKey.split('.');
     let current = activeContent;
     for (const key of keys) {
         if (current && typeof current === 'object' && key in current) {
             current = current[key];
         }
         else {
-            const msg = `[Contentstorage] getVariation: Path "${pathString}" for variation object not found in loaded content.`;
+            const msg = `[Contentstorage] getVariation: Path "${contentKey}" for variation object not found in loaded content.`;
             console.warn(msg);
-            return '';
+            return defaultVal;
         }
     }
     if (current &&
@@ -120,12 +154,18 @@ export function getVariation(pathString, variationKey, variables) {
             if (typeof variationObject.data[variationKey] === 'string') {
                 const current = variationObject.data[variationKey];
                 if (!variables || Object.keys(variables).length === 0) {
-                    return current;
+                    return {
+                        contentKey,
+                        text: current,
+                    };
                 }
-                return populateTextWithVariables(current, variables, pathString);
+                return {
+                    contentKey,
+                    text: populateTextWithVariables(current, variables, contentKey),
+                };
             }
             else {
-                const msg = `[Contentstorage] getVariation: Variation value for key "${variationKey}" at path "${pathString}" is not a string (actual type: ${typeof variationObject.data[variationKey]}).`;
+                const msg = `[Contentstorage] getVariation: Variation value for key "${variationKey}" at path "${contentKey}" is not a string (actual type: ${typeof variationObject.data[variationKey]}).`;
                 console.warn(msg);
             }
         }
@@ -133,20 +173,23 @@ export function getVariation(pathString, variationKey, variables) {
         if ('default' in variationObject.data && typeof variationKey === 'string') {
             if (typeof variationObject.data.default === 'string') {
                 if (variationKey && variationKey !== 'default') {
-                    console.warn(`[Contentstorage] getVariation: Variation key "${variationKey}" not found at path "${pathString}". Returning 'default' variation.`);
+                    console.warn(`[Contentstorage] getVariation: Variation key "${variationKey}" not found at path "${contentKey}". Returning 'default' variation.`);
                 }
-                return variationObject.data.default;
+                return {
+                    contentKey,
+                    text: variationObject.data.default,
+                };
             }
             else {
-                console.warn(`[Contentstorage] getVariation: 'default' variation value at path "${pathString}" is not a string (actual type: ${typeof variationObject.data.default}).`);
+                console.warn(`[Contentstorage] getVariation: 'default' variation value at path "${contentKey}" is not a string (actual type: ${typeof variationObject.data.default}).`);
             }
         }
         // If neither specific key nor 'default' is found or valid
-        console.warn(`[Contentstorage] getVariation: Neither variation key "${variationKey?.toString()}" nor 'default' variation found or valid at path "${pathString}".`);
-        return '';
+        console.warn(`[Contentstorage] getVariation: Neither variation key "${variationKey?.toString()}" nor 'default' variation found or valid at path "${contentKey}".`);
+        return defaultVal;
     }
     else {
-        console.warn(`[Contentstorage] getVariation: Value at path "${pathString}" is not a valid variation object (actual value: ${JSON.stringify(current)}).`);
-        return '';
+        console.warn(`[Contentstorage] getVariation: Value at path "${contentKey}" is not a valid variation object (actual value: ${JSON.stringify(current)}).`);
+        return defaultVal;
     }
 }

package/dist/lib/functions/fetchContent.d.ts

@@ -0,0 +1,2 @@
+import { LanguageCode } from '../../types.js';
+export declare function fetchContent(language?: LanguageCode): Promise<void>;

package/dist/lib/functions/fetchContent.js

@@ -0,0 +1,43 @@
+import axios from 'axios';
+import { CONTENTSTORAGE_CONFIG } from '../../contentstorage-config.js';
+import { appConfig, setContentLanguage } from '../contentManagement.js';
+export async function fetchContent(language) {
+    const languageToFetch = language || appConfig?.languageCodes?.[0];
+    console.log(`Starting content fetch for language ${language}...`);
+    if (!languageToFetch) {
+        throw Error(`No language found`);
+    }
+    if (!appConfig) {
+        throw Error(`No app config found`);
+    }
+    const fileUrl = `${CONTENTSTORAGE_CONFIG.BASE_URL}/${appConfig.contentKey}/content/${languageToFetch}.json`;
+    try {
+        // Fetch data for the current language
+        const response = await axios.get(fileUrl);
+        const jsonData = response.data;
+        // Basic check for data existence, although axios usually throws for non-2xx responses
+        if (jsonData === undefined || jsonData === null) {
+            throw new Error(`No data received from ${fileUrl} for language ${languageToFetch}.`);
+        }
+        // Validate that jsonData is a single, non-null JSON object (not an array)
+        // This check mirrors the original code's expectation for the content of a JSON file.
+        if (typeof jsonData !== 'object') {
+            throw new Error(`Expected a single JSON object from ${fileUrl} for language ${languageToFetch}, but received type ${typeof jsonData}. Cannot proceed.`);
+        }
+        console.log(`Received JSON for ${languageToFetch}`);
+        setContentLanguage(jsonData);
+    }
+    catch (error) {
+        // Catch errors related to fetching or saving a single language file
+        console.error(`\nError processing language ${languageToFetch} from ${fileUrl}:`);
+        if (axios.isAxiosError(error)) {
+            console.error(`  Status: ${error.response?.status}`);
+            console.error(`Response Data: ${error.response?.data ? JSON.stringify(error.response.data) : 'N/A'}`);
+            console.error(`  Message: ${error.message}`); // Axios error message
+        }
+        else {
+            // For non-Axios errors (e.g., manually thrown errors, fs errors)
+            console.error(`  Error: ${error.message}`);
+        }
+    }
+}

package/dist/type-generation/get-type-structure.js

@@ -1,6 +1,6 @@
-import * as hash from "hash.js";
+import * as crypto from 'crypto';
 import { TypeGroup } from './model.js';
-import { findTypeById, getTypeDescriptionGroup, isArray, isDate, isHash, isObject, onlyUnique } from './util.js';
+import { findTypeById, getTypeDescriptionGroup, isArray, isDate, isHash, isObject, onlyUnique, } from './util.js';
 function createTypeDescription(typeObj, isUnion) {
     if (isArray(typeObj)) {
         return {
@@ -27,12 +27,19 @@ function getIdByType(typeObj, types, isUnion = false) {
     return typeDesc.id;
 }
 function Hash(content) {
-    return hash.sha1().update(content).digest("hex");
+    // Create a new SHA-1 hash object
+    const sha1Hash = crypto.createHash('sha1');
+    // Update the hash object with the content
+    sha1Hash.update(content);
+    // Calculate the digest in hexadecimal format
+    return sha1Hash.digest('hex');
 }
 function typeObjectMatchesTypeDesc(typeObj, typeDesc, isUnion) {
     if (isArray(typeObj)) {
-        // @ts-expect-error
-        return arraysContainSameElements(typeObj, typeDesc.arrayOfTypes) && typeDesc.isUnion === isUnion;
+        return (
+        // @ts-ignore
+        arraysContainSameElements(typeObj, typeDesc.arrayOfTypes) &&
+            typeDesc.isUnion === isUnion);
     }
     else {
         return objectsHaveSameEntries(typeObj, typeDesc.typeObj);
@@ -41,7 +48,7 @@ function typeObjectMatchesTypeDesc(typeObj, typeDesc, isUnion) {
 function arraysContainSameElements(arr1, arr2) {
     if (arr1 === undefined || arr2 === undefined)
         return false;
-    return arr1.sort().join("") === arr2.sort().join("");
+    return arr1.sort().join('') === arr2.sort().join('');
 }
 function objectsHaveSameEntries(obj1, obj2) {
     if (obj1 === undefined || obj2 === undefined)
@@ -56,10 +63,10 @@ function objectsHaveSameEntries(obj1, obj2) {
 }
 function getSimpleTypeName(value) {
     if (value === null) {
-        return "null";
+        return 'null';
     }
     else if (value instanceof Date) {
-        return "Date";
+        return 'Date';
     }
     else {
         return typeof value;
@@ -126,11 +133,12 @@ function getMergedObjects(typesOfArray, types) {
     return getIdByType(typeObj, types, true);
 }
 function toOptionalKey(key) {
-    return key.endsWith("--?") ? key : `${key}--?`;
+    return key.endsWith('--?') ? key : `${key}--?`;
 }
 function getMergedArrays(typesOfArray, types) {
     // @ts-expect-error
-    const idsOfArrayTypes = typesOfArray?.map((typeDesc) => typeDesc.arrayOfTypes)
+    const idsOfArrayTypes = typesOfArray
+        ?.map((typeDesc) => typeDesc.arrayOfTypes)
         // @ts-expect-error
         .reduce((a, b) => [...a, ...b], [])
         .filter(onlyUnique);
@@ -155,16 +163,18 @@ function getMergedUnion(typesOfArray, types) {
 }
 function getInnerArrayType(typesOfArray, types) {
     // return inner array type
-    const containsUndefined = typesOfArray.includes("undefined");
-    const arrayTypesDescriptions = typesOfArray.map((id) => findTypeById(id, types)).filter((_) => !!_);
-    const allArrayType = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Array).length ===
-        typesOfArray.length;
-    const allArrayTypeWithUndefined = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Array).length + 1 ===
+    const containsUndefined = typesOfArray.includes('undefined');
+    const arrayTypesDescriptions = typesOfArray
+        .map((id) => findTypeById(id, types))
+        .filter((_) => !!_);
+    const allArrayType = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Array).length === typesOfArray.length;
+    const allArrayTypeWithUndefined = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Array).length +
+        1 ===
         typesOfArray.length && containsUndefined;
-    const allObjectTypeWithUndefined = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Object).length + 1 ===
+    const allObjectTypeWithUndefined = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Object).length +
+        1 ===
         typesOfArray.length && containsUndefined;
-    const allObjectType = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Object).length ===
-        typesOfArray.length;
+    const allObjectType = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Object).length === typesOfArray.length;
     if (typesOfArray.length === 0) {
         // no types in array -> empty union type
         return getIdByType([], types, true);
@@ -183,11 +193,11 @@ function getInnerArrayType(typesOfArray, types) {
             return getMergedArrays(arrayTypesDescriptions, types);
         // all array types with posibble undefined, result type = undefined | (*mergedArray*)[]
         if (allArrayTypeWithUndefined) {
-            return getMergedUnion([getMergedArrays(arrayTypesDescriptions, types), "undefined"], types);
+            return getMergedUnion([getMergedArrays(arrayTypesDescriptions, types), 'undefined'], types);
         }
         // all object types with posibble undefined, result type = undefined | *mergedObject*
         if (allObjectTypeWithUndefined) {
-            return getMergedUnion([getMergedObjects(arrayTypesDescriptions, types), "undefined"], types);
+            return getMergedUnion([getMergedObjects(arrayTypesDescriptions, types), 'undefined'], types);
         }
         // if they are mixed or all primitive we cant merge them so we return as mixed union type
         return getMergedUnion(typesOfArray, types);
@@ -197,7 +207,9 @@ export function getTypeStructure(targetObj, // object that we want to create typ
 types = []) {
     switch (getTypeGroup(targetObj)) {
         case TypeGroup.Array:
-            const typesOfArray = targetObj.map((_) => getTypeStructure(_, types).rootTypeId).filter(onlyUnique);
+            const typesOfArray = targetObj
+                .map((_) => getTypeStructure(_, types).rootTypeId)
+                .filter(onlyUnique);
             const arrayInnerTypeId = getInnerArrayType(typesOfArray, types); // create "union type of array types"
             const typeId = getIdByType([arrayInnerTypeId], types); // create type "array of union type"
             return {

package/dist/types.d.ts

@@ -22,6 +22,18 @@ export type LanguageCode = 'SQ' | 'BE' | 'BS' | 'BG' | 'HR' | 'CS' | 'DA' | 'NL'
  */
 export interface ContentStructure {
 }
+export type GetTextReturn = {
+    contentKey: string;
+    text: string;
+};
+export type GetImageReturn = {
+    contentKey: string;
+    data: ImageObject;
+};
+export type GetVariationReturn = {
+    contentKey: string;
+    text: string;
+};
 export interface ImageObject {
     contentstorage_type: 'image';
     url: string;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@contentstorage/core",
   "author": "Kaido Hussar <kaidohus@gmail.com>",
   "homepage": "https://contentstorage.app",
-  "version": "0.3.31",
+  "version": "0.3.33",
   "type": "module",
   "description": "Fetch content from contentstorage and generate TypeScript types",
   "module": "dist/index.js",
@@ -28,7 +28,6 @@
     "axios": "^1.7.2",
     "chalk": "^4.1.2",
     "es7-shim": "^6.0.0",
-    "hash.js": "^1.0.3",
     "pluralize": "^3.1.0"
   },
   "devDependencies": {