@contentstorage/core 0.3.30 → 0.3.32

package/dist/helpers/populateTextWithVariables.d.ts

@@ -0,0 +1 @@
+export declare function populateTextWithVariables(text: string, variables: Record<string, any>, textKey: string): string;

package/dist/helpers/populateTextWithVariables.js

@@ -0,0 +1,10 @@
+export function populateTextWithVariables(text, variables, textKey) {
+    return text.replace(/\{(\w+)}/g, (placeholder, variableName) => {
+        if (Object.prototype.hasOwnProperty.call(variables, variableName)) {
+            const value = variables[variableName];
+            return String(value);
+        }
+        console.warn(`[getText] Variable "${variableName}" for text id "${textKey}" not found in provided variables. Placeholder "${placeholder}" will be replaced with an empty string.`);
+        return placeholder;
+    });
+}

package/dist/lib/configLoader.js

@@ -1,5 +1,6 @@
 import path from 'path';
 import fs from 'fs';
+import chalk from 'chalk';
 const DEFAULT_CONFIG = {
     languageCodes: [],
     contentDir: path.join('src', 'content', 'json'),
@@ -13,19 +14,19 @@ export async function loadConfig() {
             // Use require for JS config file
             const loadedModule = await import(configPath);
             userConfig = loadedModule.default || loadedModule;
-            console.log('Loaded config', JSON.stringify(userConfig));
-            console.log(`Loaded configuration from ${configPath}`);
+            console.log(chalk.blue('Loaded config', JSON.stringify(userConfig)));
+            console.log(chalk.blue(`Loaded configuration from ${configPath}`));
         }
         catch (error) {
-            console.error(`Error loading configuration from ${configPath}:`, error);
+            console.error(chalk.red(`Error loading configuration from ${configPath}:`, error));
             // Decide if you want to proceed with defaults or exit
             // For now, we'll proceed with defaults but warn
-            console.warn('Proceeding with default configuration.');
+            console.warn(chalk.yellow('Proceeding with default configuration.'));
             userConfig = {}; // Reset in case of partial load failure
         }
     }
     else {
-        console.log('No content.config.js found. Using default configuration.');
+        console.log(chalk.blue('No content.config.js found. Using default configuration.'));
     }
     const mergedConfig = {
         ...DEFAULT_CONFIG,
@@ -33,7 +34,7 @@ export async function loadConfig() {
     };
     // Validate required fields
     if (!mergedConfig.contentKey) {
-        console.error('Error: Configuration is missing the required "contentKey" property.');
+        console.error(chalk.red('Error: Configuration is missing the required "contentKey" property.'));
         process.exit(1);
     }
     const finalConfig = {

package/dist/lib/contentManagement.d.ts

@@ -11,12 +11,15 @@ export declare function setContentLanguage(contentJson: object): void;
  * `setContentLanguage()` must be called successfully before using this.
  *
  * @param pathString 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(pathString: keyof ContentStructure, fallbackValue?: string): string | undefined;
+export declare function getText<Path extends keyof ContentStructure>(pathString: 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 {
     data: infer D;
-} ? keyof D : string, fallbackString?: string): string | undefined;
+} ? keyof D : string, variables?: Record<string, any>): string | undefined;

package/dist/lib/contentManagement.js

@@ -1,3 +1,4 @@
+import { populateTextWithVariables } from '../helpers/populateTextWithVariables.js';
 let activeContent = null;
 /**
  * Loads and sets the content for a specific language.
@@ -23,15 +24,16 @@ export function setContentLanguage(contentJson) {
  * `setContentLanguage()` must be called successfully before using this.
  *
  * @param pathString 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, fallbackValue) {
+export function getText(pathString, variables) {
     if (!activeContent) {
         const msg = `[Contentstorage] getText: Content not loaded (Key: "${String(pathString)}"). Ensure setContentLanguage() was called and completed successfully.`;
         console.warn(msg);
-        return fallbackValue;
+        return '';
     }
     const keys = pathString.split('.');
     let current = activeContent;
@@ -42,16 +44,19 @@ export function getText(pathString, fallbackValue) {
         else {
             const msg = `[Contentstorage] getText: Path "${String(pathString)}" not found in loaded content.`;
             console.warn(msg);
-            return fallbackValue;
+            return '';
         }
     }
     if (typeof current === 'string') {
-        return current;
+        if (!variables || Object.keys(variables).length === 0) {
+            return current;
+        }
+        return populateTextWithVariables(current, variables, pathString);
     }
     else {
         const msg = `[Contentstorage] getText: Value at path "${String(pathString)}" is not a string (actual type: ${typeof current}).`;
         console.warn(msg);
-        return fallbackValue;
+        return '';
     }
 }
 export function getImage(pathString, fallbackValue) {
@@ -85,11 +90,11 @@ export function getImage(pathString, fallbackValue) {
         return fallbackValue;
     }
 }
-export function getVariation(pathString, variationKey, fallbackString) {
+export function getVariation(pathString, variationKey, variables) {
     if (!activeContent) {
         const msg = `[Contentstorage] getVariation: Content not loaded (Key: "${pathString}", Variation: "${variationKey?.toString()}"). Ensure setContentLanguage() was called and completed successfully.`;
         console.warn(msg);
-        return fallbackString;
+        return '';
     }
     const keys = pathString.split('.');
     let current = activeContent;
@@ -100,7 +105,7 @@ export function getVariation(pathString, variationKey, fallbackString) {
         else {
             const msg = `[Contentstorage] getVariation: Path "${pathString}" for variation object not found in loaded content.`;
             console.warn(msg);
-            return fallbackString;
+            return '';
         }
     }
     if (current &&
@@ -113,7 +118,11 @@ export function getVariation(pathString, variationKey, fallbackString) {
             typeof variationKey === 'string' &&
             variationKey in variationObject.data) {
             if (typeof variationObject.data[variationKey] === 'string') {
-                return variationObject.data[variationKey];
+                const current = variationObject.data[variationKey];
+                if (!variables || Object.keys(variables).length === 0) {
+                    return current;
+                }
+                return populateTextWithVariables(current, variables, pathString);
             }
             else {
                 const msg = `[Contentstorage] getVariation: Variation value for key "${variationKey}" at path "${pathString}" is not a string (actual type: ${typeof variationObject.data[variationKey]}).`;
@@ -124,25 +133,20 @@ export function getVariation(pathString, variationKey, fallbackString) {
         if ('default' in variationObject.data && typeof variationKey === 'string') {
             if (typeof variationObject.data.default === 'string') {
                 if (variationKey && variationKey !== 'default') {
-                    // Warn if specific key was requested but default is being returned
-                    const msg = `[Contentstorage] getVariation: Variation key "${variationKey}" not found at path "${pathString}". Returning 'default' variation.`;
-                    console.warn(msg);
+                    console.warn(`[Contentstorage] getVariation: Variation key "${variationKey}" not found at path "${pathString}". Returning 'default' variation.`);
                 }
                 return variationObject.data.default;
             }
             else {
-                const msg = `[Contentstorage] getVariation: 'default' variation value at path "${pathString}" is not a string (actual type: ${typeof variationObject.data.default}).`;
-                console.warn(msg);
+                console.warn(`[Contentstorage] getVariation: 'default' variation value at path "${pathString}" is not a string (actual type: ${typeof variationObject.data.default}).`);
             }
         }
         // If neither specific key nor 'default' is found or valid
-        const msg = `[Contentstorage] getVariation: Neither variation key "${variationKey?.toString()}" nor 'default' variation found or valid at path "${pathString}".`;
-        console.warn(msg);
-        return fallbackString;
+        console.warn(`[Contentstorage] getVariation: Neither variation key "${variationKey?.toString()}" nor 'default' variation found or valid at path "${pathString}".`);
+        return '';
     }
     else {
-        const msg = `[Contentstorage] getVariation: Value at path "${pathString}" is not a valid variation object (actual value: ${JSON.stringify(current)}).`;
-        console.warn(msg);
-        return fallbackString;
+        console.warn(`[Contentstorage] getVariation: Value at path "${pathString}" is not a valid variation object (actual value: ${JSON.stringify(current)}).`);
+        return '';
     }
 }

package/dist/scripts/generate-types.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
-// ^ Shebang ensures the script is executed with Node.js
+// ^ Ensures the script is executed with Node.js
 import fs from 'fs/promises';
 import path from 'path';
 import axios from 'axios';
-import jsonToTS from 'json-to-ts'; // Import the library
 import chalk from 'chalk'; // Optional: for colored output
 import { loadConfig } from '../lib/configLoader.js';
 import { flattenJson } from '../helpers/flattenJson.js';
 import { CONTENTSTORAGE_CONFIG } from '../contentstorage-config.js';
+import { jsonToTS } from '../type-generation/index.js';
 export async function generateTypes() {
     console.log(chalk.blue('Starting type generation...'));
     const config = await loadConfig();
@@ -104,9 +104,9 @@ export async function generateTypes() {
             }
         }
         // Generate TypeScript interfaces using json-to-ts
-        const rootTypeName = 'ContentRoot'; // As per your previous update
+        const rootTypeName = 'ContentRoot';
         console.log(chalk.blue(`Generating TypeScript types with root name '${rootTypeName}'...`));
-        const typeDeclarations = jsonToTS.default(jsonObject, {
+        const typeDeclarations = jsonToTS(jsonObject, {
             rootName: rootTypeName,
         });
         if (!typeDeclarations || typeDeclarations.length === 0) {

package/dist/scripts/pull-content.js

@@ -44,11 +44,7 @@ export async function pullContent() {
                     Array.isArray(jsonData) /* jsonData === null is already covered */) {
                     throw new Error(`Expected a single JSON object from ${fileUrl} for language ${languageCode}, but received type ${Array.isArray(jsonData) ? 'array' : typeof jsonData}. Cannot save the file.`);
                 }
-                console.log(chalk.green(`Received and json for ${languageCode}. Saving to ${outputPath}`));
-                await fs.writeFile(outputPath, JSON.stringify(jsonData, null, 2));
-                console.log(chalk.green(`Successfully saved ${outputPath}`));
                 console.log(chalk.green(`Received JSON for ${languageCode}. Saving to ${outputPath}`));
-                // Write the JSON data to the file
                 await fs.writeFile(outputPath, JSON.stringify(jsonData, null, 2));
                 console.log(chalk.green(`Successfully saved ${outputPath}`));
             }

package/dist/type-generation/get-interfaces.d.ts

@@ -0,0 +1,5 @@
+import { InterfaceDescription, NameEntry, TypeStructure } from './model.js';
+export declare function getInterfaceStringFromDescription({ name, typeMap, isRoot, }: InterfaceDescription & {
+    isRoot?: boolean;
+}): string;
+export declare function getInterfaceDescriptions(typeStructure: TypeStructure, names: NameEntry[]): InterfaceDescription[];

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

@@ -0,0 +1,97 @@
+import { findTypeById, isHash, isNonArrayUnion } from './util.js';
+function isKeyNameValid(keyName) {
+    const regex = /^[a-zA-Z_][a-zA-Z\d_]*$/;
+    return regex.test(keyName);
+}
+function parseKeyMetaData(key) {
+    const isOptional = key.endsWith('--?');
+    if (isOptional) {
+        return {
+            isOptional,
+            keyValue: key.slice(0, -3),
+        };
+    }
+    else {
+        return {
+            isOptional,
+            keyValue: key,
+        };
+    }
+}
+function findNameById(id, names) {
+    // @ts-expect-error
+    return names.find((_) => _.id === id).name;
+}
+function removeUndefinedFromUnion(unionTypeName) {
+    const typeNames = unionTypeName.split(' | ');
+    const undefinedIndex = typeNames.indexOf('undefined');
+    typeNames.splice(undefinedIndex, 1);
+    return typeNames.join(' | ');
+}
+function replaceTypeObjIdsWithNames(typeObj, names) {
+    return (Object.entries(typeObj)
+        // quote key if is invalid and question mark if optional from array merging
+        .map(([key, type]) => {
+        const { isOptional, keyValue } = parseKeyMetaData(key);
+        const isValid = isKeyNameValid(keyValue);
+        const validName = isValid ? keyValue : `'${keyValue}'`;
+        return isOptional
+            ? [`${validName}?`, type, isOptional]
+            : [validName, type, isOptional];
+    })
+        // replace hashes with names referencing the hashes
+        .map(([key, type, isOptional]) => {
+        if (!isHash(type)) {
+            return [key, type, isOptional];
+        }
+        const newType = findNameById(type, names);
+        return [key, newType, isOptional];
+    })
+        // if union has undefined, remove undefined and make type optional
+        .map(([key, type, isOptional]) => {
+        if (!(isNonArrayUnion(type) && type.includes('undefined'))) {
+            return [key, type, isOptional];
+        }
+        const newType = removeUndefinedFromUnion(type);
+        const newKey = isOptional ? key : `${key}?`; // if already optional dont add question mark
+        return [newKey, newType, isOptional];
+    })
+        // make undefined optional and set type as any
+        .map(([key, type, isOptional]) => {
+        if (type !== 'undefined') {
+            return [key, type, isOptional];
+        }
+        const newType = 'any';
+        const newKey = isOptional ? key : `${key}?`; // if already optional dont add question mark
+        return [newKey, newType, isOptional];
+    })
+        .reduce((agg, [key, value]) => {
+        // @ts-expect-error
+        agg[key] = value;
+        return agg;
+    }, {}));
+}
+export function getInterfaceStringFromDescription({ name, typeMap, isRoot, }) {
+    const stringTypeMap = Object.entries(typeMap)
+        .map(([key, name]) => `  ${key}: ${name};\n`)
+        .reduce((a, b) => (a += b), '');
+    const declarationKeyWord = 'interface';
+    let interfaceString = `${isRoot ? 'export ' : ''}${declarationKeyWord} ${name} {\n`;
+    interfaceString += stringTypeMap;
+    interfaceString += '}';
+    return interfaceString;
+}
+export function getInterfaceDescriptions(typeStructure, names) {
+    return names
+        .map(({ id, name }) => {
+        const typeDescription = findTypeById(id, typeStructure.types);
+        if (typeDescription.typeObj) {
+            const typeMap = replaceTypeObjIdsWithNames(typeDescription.typeObj, names);
+            return { name, typeMap };
+        }
+        else {
+            return null;
+        }
+    })
+        .filter((_) => _ !== null);
+}

package/dist/type-generation/get-names.d.ts

@@ -0,0 +1,2 @@
+import { NameEntry, TypeStructure } from './model.js';
+export declare function getNames(typeStructure: TypeStructure, rootName?: string): NameEntry[];

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

@@ -0,0 +1,142 @@
+// @ts-expect-error
+import * as pluralize from "pluralize";
+import { TypeGroup } from './model.js';
+import { findTypeById, getTypeDescriptionGroup, isHash, parseKeyMetaData } from './util.js';
+function getName({ rootTypeId, types }, keyName, names, isInsideArray
+// @ts-ignore
+) {
+    const typeDesc = types.find((_) => _.id === rootTypeId);
+    switch (getTypeDescriptionGroup(typeDesc)) {
+        case TypeGroup.Array:
+            // @ts-expect-error
+            typeDesc.arrayOfTypes.forEach((typeIdOrPrimitive, i) => {
+                getName({ rootTypeId: typeIdOrPrimitive, types }, 
+                // to differenttiate array types
+                i === 0 ? keyName : `${keyName}${i + 1}`, names, true);
+            });
+            return {
+                rootName: getNameById(typeDesc.id, keyName, isInsideArray, types, names),
+                names,
+            };
+        case TypeGroup.Object:
+            Object.entries(typeDesc.typeObj).forEach(([key, value]) => {
+                getName({ rootTypeId: value, types }, key, names, false);
+            });
+            return {
+                rootName: getNameById(typeDesc.id, keyName, isInsideArray, types, names),
+                names,
+            };
+        case TypeGroup.Primitive:
+            // in this case rootTypeId is primitive type string (string, null, number, boolean)
+            return {
+                rootName: rootTypeId,
+                names,
+            };
+    }
+}
+export function getNames(typeStructure, rootName = "RootObject") {
+    return getName(typeStructure, rootName, [], false).names.reverse();
+}
+function getNameById(id, keyName, isInsideArray, types, nameMap) {
+    const nameEntry = nameMap.find((_) => _.id === id);
+    if (nameEntry) {
+        return nameEntry.name;
+    }
+    const typeDesc = findTypeById(id, types);
+    const group = getTypeDescriptionGroup(typeDesc);
+    let name;
+    switch (group) {
+        case TypeGroup.Array:
+            name = typeDesc.isUnion ? getArrayName(typeDesc, types, nameMap) : formatArrayName(typeDesc, types, nameMap);
+            break;
+        case TypeGroup.Object:
+            /**
+             * picking name for type in array requires to singularize that type name,
+             * and if not then no need to singularize
+             */
+            name = [keyName]
+                .map((key) => parseKeyMetaData(key).keyValue)
+                .map((name) => (isInsideArray ? pluralize.singular(name) : name))
+                .map(pascalCase)
+                .map(normalizeInvalidTypeName)
+                .map(pascalCase) // needed because removed symbols might leave first character uncapitalized
+                .map((name) => uniqueByIncrement(name, nameMap.map(({ name }) => name)))
+                .pop();
+            break;
+    }
+    // @ts-ignore
+    nameMap.push({ id, name });
+    // @ts-ignore
+    return name;
+}
+function pascalCase(name) {
+    return name
+        .split(/\s+/g)
+        .filter((_) => _ !== "")
+        .map(capitalize)
+        .reduce((a, b) => a + b, "");
+}
+function capitalize(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function normalizeInvalidTypeName(name) {
+    if (/^[a-zA-Z][a-zA-Z0-9]*$/.test(name)) {
+        return name;
+    }
+    else {
+        const noSymbolsName = name.replace(/[^a-zA-Z0-9]/g, "");
+        const startsWithWordCharacter = /^[a-zA-Z]/.test(noSymbolsName);
+        return startsWithWordCharacter ? noSymbolsName : `_${noSymbolsName}`;
+    }
+}
+function uniqueByIncrement(name, names) {
+    for (let i = 0; i < 1000; i++) {
+        const nameProposal = i === 0 ? name : `${name}${i + 1}`;
+        if (!names.includes(nameProposal)) {
+            return nameProposal;
+        }
+    }
+}
+function getArrayName(typeDesc, types, nameMap) {
+    // @ts-ignore
+    if (typeDesc.arrayOfTypes.length === 0) {
+        return "any";
+    }
+    else { // @ts-ignore
+        if (typeDesc.arrayOfTypes.length === 1) {
+            // @ts-ignore
+            const [idOrPrimitive] = typeDesc.arrayOfTypes;
+            return convertToReadableType(idOrPrimitive, types, nameMap);
+        }
+        else {
+            return unionToString(typeDesc, types, nameMap);
+        }
+    }
+}
+function convertToReadableType(idOrPrimitive, types, nameMap) {
+    return isHash(idOrPrimitive)
+        ? // array keyName makes no difference in picking name for type
+            // @ts-ignore
+            getNameById(idOrPrimitive, null, true, types, nameMap)
+        : idOrPrimitive;
+}
+function unionToString(typeDesc, types, nameMap) {
+    // @ts-ignore
+    return typeDesc.arrayOfTypes.reduce((acc, type, i) => {
+        const readableTypeName = convertToReadableType(type, types, nameMap);
+        return i === 0 ? readableTypeName : `${acc} | ${readableTypeName}`;
+    }, "");
+}
+function formatArrayName(typeDesc, types, nameMap) {
+    // @ts-ignore
+    const innerTypeId = typeDesc.arrayOfTypes[0];
+    // const isMultipleTypeArray = findTypeById(innerTypeId, types).arrayOfTypes.length > 1
+    const isMultipleTypeArray = isHash(innerTypeId) &&
+        findTypeById(innerTypeId, types).isUnion &&
+        // @ts-ignore
+        findTypeById(innerTypeId, types).arrayOfTypes.length > 1;
+    const readableInnerType = getArrayName(typeDesc, types, nameMap);
+    return isMultipleTypeArray
+        ? `(${readableInnerType})[]` // add semicolons for union type
+        : `${readableInnerType}[]`;
+}

package/dist/type-generation/get-type-structure.d.ts

@@ -0,0 +1,4 @@
+import { TypeDescription, TypeStructure } from './model.js';
+export declare function getTypeStructure(targetObj: any, // object that we want to create types for
+types?: TypeDescription[]): TypeStructure;
+export declare function optimizeTypeStructure(typeStructure: TypeStructure): void;

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

@@ -0,0 +1,270 @@
+import * as crypto from 'crypto';
+import { TypeGroup } from './model.js';
+import { findTypeById, getTypeDescriptionGroup, isArray, isDate, isHash, isObject, onlyUnique, } from './util.js';
+function createTypeDescription(typeObj, isUnion) {
+    if (isArray(typeObj)) {
+        return {
+            id: Hash(JSON.stringify([...typeObj, isUnion])),
+            arrayOfTypes: typeObj,
+            isUnion,
+        };
+    }
+    else {
+        return {
+            id: Hash(JSON.stringify(typeObj)),
+            typeObj,
+        };
+    }
+}
+function getIdByType(typeObj, types, isUnion = false) {
+    let typeDesc = types.find((el) => {
+        return typeObjectMatchesTypeDesc(typeObj, el, isUnion);
+    });
+    if (!typeDesc) {
+        typeDesc = createTypeDescription(typeObj, isUnion);
+        types.push(typeDesc);
+    }
+    return typeDesc.id;
+}
+function Hash(content) {
+    // 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)) {
+        return (
+        // @ts-ignore
+        arraysContainSameElements(typeObj, typeDesc.arrayOfTypes) &&
+            typeDesc.isUnion === isUnion);
+    }
+    else {
+        return objectsHaveSameEntries(typeObj, typeDesc.typeObj);
+    }
+}
+function arraysContainSameElements(arr1, arr2) {
+    if (arr1 === undefined || arr2 === undefined)
+        return false;
+    return arr1.sort().join('') === arr2.sort().join('');
+}
+function objectsHaveSameEntries(obj1, obj2) {
+    if (obj1 === undefined || obj2 === undefined)
+        return false;
+    const entries1 = Object.entries(obj1);
+    const entries2 = Object.entries(obj2);
+    const sameLength = entries1.length === entries2.length;
+    const sameTypes = entries1.every(([key, value]) => {
+        return obj2[key] === value;
+    });
+    return sameLength && sameTypes;
+}
+function getSimpleTypeName(value) {
+    if (value === null) {
+        return 'null';
+    }
+    else if (value instanceof Date) {
+        return 'Date';
+    }
+    else {
+        return typeof value;
+    }
+}
+function getTypeGroup(value) {
+    if (isDate(value)) {
+        return TypeGroup.Date;
+    }
+    else if (isArray(value)) {
+        return TypeGroup.Array;
+    }
+    else if (isObject(value)) {
+        return TypeGroup.Object;
+    }
+    else {
+        return TypeGroup.Primitive;
+    }
+}
+function createTypeObject(obj, types) {
+    return Object.entries(obj).reduce((typeObj, [key, value]) => {
+        const { rootTypeId } = getTypeStructure(value, types);
+        return {
+            ...typeObj,
+            [key]: rootTypeId,
+        };
+    }, {});
+}
+function getMergedObjects(typesOfArray, types) {
+    const typeObjects = typesOfArray.map((typeDesc) => typeDesc.typeObj);
+    const allKeys = typeObjects
+        // @ts-expect-error
+        .map((typeObj) => Object.keys(typeObj))
+        .reduce((a, b) => [...a, ...b], [])
+        .filter(onlyUnique);
+    const commonKeys = typeObjects.reduce((commonKeys, typeObj) => {
+        // @ts-expect-error
+        const keys = Object.keys(typeObj);
+        return commonKeys.filter((key) => keys.includes(key));
+    }, allKeys);
+    const getKeyType = (key) => {
+        const typesOfKey = typeObjects
+            .filter((typeObj) => {
+            return Object.keys(typeObj).includes(key);
+        })
+            .map((typeObj) => typeObj[key])
+            .filter(onlyUnique);
+        if (typesOfKey.length === 1) {
+            return typesOfKey.pop();
+        }
+        else {
+            return getInnerArrayType(typesOfKey, types);
+        }
+    };
+    const typeObj = allKeys.reduce((obj, key) => {
+        const isMandatory = commonKeys.includes(key);
+        const type = getKeyType(key);
+        const keyValue = isMandatory ? key : toOptionalKey(key);
+        return {
+            ...obj,
+            [keyValue]: type,
+        };
+    }, {});
+    return getIdByType(typeObj, types, true);
+}
+function toOptionalKey(key) {
+    return key.endsWith('--?') ? key : `${key}--?`;
+}
+function getMergedArrays(typesOfArray, types) {
+    // @ts-expect-error
+    const idsOfArrayTypes = typesOfArray
+        ?.map((typeDesc) => typeDesc.arrayOfTypes)
+        // @ts-expect-error
+        .reduce((a, b) => [...a, ...b], [])
+        .filter(onlyUnique);
+    if (idsOfArrayTypes.length === 1) {
+        return getIdByType([idsOfArrayTypes.pop()], types);
+    }
+    else {
+        return getIdByType([getInnerArrayType(idsOfArrayTypes, types)], types);
+    }
+}
+// we merge union types example: (number | string), null -> (number | string | null)
+function getMergedUnion(typesOfArray, types) {
+    const innerUnionsTypes = typesOfArray
+        .map((id) => {
+        return findTypeById(id, types);
+    })
+        .filter((_) => !!_ && _.isUnion)
+        .map((_) => _.arrayOfTypes)
+        .reduce((a, b) => [...a, ...b], []);
+    const primitiveTypes = typesOfArray.filter((id) => !findTypeById(id, types) || !findTypeById(id, types).isUnion); // primitives or not union
+    return getIdByType([...innerUnionsTypes, ...primitiveTypes], types, true);
+}
+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 ===
+        typesOfArray.length && containsUndefined;
+    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;
+    if (typesOfArray.length === 0) {
+        // no types in array -> empty union type
+        return getIdByType([], types, true);
+    }
+    if (typesOfArray.length === 1) {
+        // one type in array -> that will be our inner type
+        return typesOfArray.pop();
+    }
+    if (typesOfArray.length > 1) {
+        // multiple types in merge array
+        // if all are object we can merge them and return merged object as inner type
+        if (allObjectType)
+            return getMergedObjects(arrayTypesDescriptions, types);
+        // if all are array we can merge them and return merged array as inner type
+        if (allArrayType)
+            return getMergedArrays(arrayTypesDescriptions, types);
+        // all array types with posibble undefined, result type = undefined | (*mergedArray*)[]
+        if (allArrayTypeWithUndefined) {
+            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);
+        }
+        // if they are mixed or all primitive we cant merge them so we return as mixed union type
+        return getMergedUnion(typesOfArray, types);
+    }
+}
+export function getTypeStructure(targetObj, // object that we want to create types for
+types = []) {
+    switch (getTypeGroup(targetObj)) {
+        case TypeGroup.Array:
+            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 {
+                rootTypeId: typeId,
+                types,
+            };
+        case TypeGroup.Object:
+            const typeObj = createTypeObject(targetObj, types);
+            const objType = getIdByType(typeObj, types);
+            return {
+                rootTypeId: objType,
+                types,
+            };
+        case TypeGroup.Primitive:
+            return {
+                rootTypeId: getSimpleTypeName(targetObj),
+                types,
+            };
+        case TypeGroup.Date:
+            const dateType = getSimpleTypeName(targetObj);
+            return {
+                rootTypeId: dateType,
+                types,
+            };
+    }
+}
+function getAllUsedTypeIds({ rootTypeId, types }) {
+    const typeDesc = types.find((_) => _.id === rootTypeId);
+    const subTypes = (typeDesc) => {
+        switch (getTypeDescriptionGroup(typeDesc)) {
+            case TypeGroup.Array:
+                const arrSubTypes = typeDesc.arrayOfTypes
+                    .filter(isHash)
+                    .map((typeId) => {
+                    const typeDesc = types.find((_) => _.id === typeId);
+                    return subTypes(typeDesc);
+                })
+                    .reduce((a, b) => [...a, ...b], []);
+                return [typeDesc.id, ...arrSubTypes];
+            case TypeGroup.Object:
+                const objSubTypes = Object.values(typeDesc.typeObj)
+                    // @ts-expect-error
+                    .filter(isHash)
+                    .map((typeId) => {
+                    const typeDesc = types.find((_) => _.id === typeId);
+                    return subTypes(typeDesc);
+                })
+                    .reduce((a, b) => [...a, ...b], []);
+                return [typeDesc.id, ...objSubTypes];
+        }
+    };
+    return subTypes(typeDesc);
+}
+export function optimizeTypeStructure(typeStructure) {
+    const usedTypeIds = getAllUsedTypeIds(typeStructure);
+    const optimizedTypes = typeStructure.types.filter((typeDesc) => usedTypeIds.includes(typeDesc.id));
+    typeStructure.types = optimizedTypes;
+}

package/dist/type-generation/index.d.ts

@@ -0,0 +1,2 @@
+import { Options } from './model.js';
+export declare function jsonToTS(json: any, userOptions?: Options): string[];

package/dist/type-generation/index.js

@@ -0,0 +1,34 @@
+import { isArray, isObject } from './util.js';
+import { getTypeStructure, optimizeTypeStructure, } from './get-type-structure.js';
+import { getNames } from './get-names.js';
+import { getInterfaceDescriptions, getInterfaceStringFromDescription, } from './get-interfaces.js';
+export function jsonToTS(json, userOptions) {
+    const defaultOptions = {
+        rootName: 'RootObject',
+    };
+    const options = {
+        ...defaultOptions,
+        ...userOptions,
+    };
+    /**
+     * Parsing currently works with (Objects) and (Array of Objects) not and primitive types and mixed arrays etc..
+     * so we shall validate, so we dont start parsing non Object type
+     */
+    const isArrayOfObjects = isArray(json) &&
+        json.length > 0 &&
+        json.reduce((a, b) => a && isObject(b), true);
+    if (!(isObject(json) || isArrayOfObjects)) {
+        throw new Error('Only (Object) and (Array of Object) are supported');
+    }
+    const typeStructure = getTypeStructure(json);
+    /**
+     * due to merging array types some types are switched out for merged ones
+     * so we delete the unused ones here
+     */
+    optimizeTypeStructure(typeStructure);
+    const names = getNames(typeStructure, options.rootName);
+    return getInterfaceDescriptions(typeStructure, names).map((description) => getInterfaceStringFromDescription({
+        ...description,
+        isRoot: options.rootName === description.name,
+    }));
+}

package/dist/type-generation/model.d.ts

@@ -0,0 +1,39 @@
+export declare enum TypeGroup {
+    Primitive = 0,
+    Array = 1,
+    Object = 2,
+    Date = 3
+}
+export interface TypeDescription {
+    id: string;
+    isUnion?: boolean;
+    typeObj?: {
+        [index: string]: string;
+    };
+    arrayOfTypes?: string[];
+}
+export interface TypeStructure {
+    rootTypeId: string;
+    types: TypeDescription[];
+}
+export interface NameEntry {
+    id: string;
+    name: string;
+}
+export interface NameStructure {
+    rootName: string;
+    names: NameEntry[];
+}
+export interface InterfaceDescription {
+    name: string;
+    typeMap: object;
+}
+export interface Options {
+    rootName?: string;
+    /** To generate using type alias instead of interface */
+    useTypeAlias?: boolean;
+}
+export interface KeyMetaData {
+    keyValue: string;
+    isOptional: boolean;
+}

package/dist/type-generation/model.js

@@ -0,0 +1,7 @@
+export var TypeGroup;
+(function (TypeGroup) {
+    TypeGroup[TypeGroup["Primitive"] = 0] = "Primitive";
+    TypeGroup[TypeGroup["Array"] = 1] = "Array";
+    TypeGroup[TypeGroup["Object"] = 2] = "Object";
+    TypeGroup[TypeGroup["Date"] = 3] = "Date";
+})(TypeGroup || (TypeGroup = {}));

package/dist/type-generation/util.d.ts

@@ -0,0 +1,10 @@
+import { KeyMetaData, TypeDescription, TypeGroup } from './model.js';
+export declare function isHash(str: string): boolean;
+export declare function onlyUnique(value: any, index: any, self: any): boolean;
+export declare function isArray(x: any): boolean;
+export declare function isNonArrayUnion(typeName: string): boolean;
+export declare function isObject(x: any): boolean;
+export declare function isDate(x: any): x is Date;
+export declare function parseKeyMetaData(key: string): KeyMetaData;
+export declare function getTypeDescriptionGroup(desc: TypeDescription): TypeGroup;
+export declare function findTypeById(id: string, types: TypeDescription[]): TypeDescription;

package/dist/type-generation/util.js

@@ -0,0 +1,49 @@
+import { TypeGroup } from './model.js';
+export function isHash(str) {
+    return str.length === 40;
+}
+export function onlyUnique(value, index, self) {
+    return self.indexOf(value) === index;
+}
+export function isArray(x) {
+    return Object.prototype.toString.call(x) === "[object Array]";
+}
+export function isNonArrayUnion(typeName) {
+    const arrayUnionRegex = /^\(.*\)\[\]$/;
+    return typeName.includes(" | ") && !arrayUnionRegex.test(typeName);
+}
+export function isObject(x) {
+    return Object.prototype.toString.call(x) === "[object Object]" && x !== null;
+}
+export function isDate(x) {
+    return x instanceof Date;
+}
+export function parseKeyMetaData(key) {
+    const isOptional = key.endsWith("--?");
+    if (isOptional) {
+        return {
+            isOptional,
+            keyValue: key.slice(0, -3)
+        };
+    }
+    else {
+        return {
+            isOptional,
+            keyValue: key
+        };
+    }
+}
+export function getTypeDescriptionGroup(desc) {
+    if (desc === undefined) {
+        return TypeGroup.Primitive;
+    }
+    else if (desc.arrayOfTypes !== undefined) {
+        return TypeGroup.Array;
+    }
+    else {
+        return TypeGroup.Object;
+    }
+}
+export function findTypeById(id, types) {
+    return types.find(_ => _.id === id);
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@contentstorage/core",
   "author": "Kaido Hussar <kaidohus@gmail.com>",
   "homepage": "https://contentstorage.app",
-  "version": "0.3.30",
+  "version": "0.3.32",
   "type": "module",
   "description": "Fetch content from contentstorage and generate TypeScript types",
   "module": "dist/index.js",
@@ -27,7 +27,8 @@
   "dependencies": {
     "axios": "^1.7.2",
     "chalk": "^4.1.2",
-    "json-to-ts": "^2.0.1"
+    "es7-shim": "^6.0.0",
+    "pluralize": "^3.1.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",

package/dist/helpers/defineConfig.d.ts

@@ -1,6 +0,0 @@
-import { AppConfig } from '../types.js';
-/**
- * Helper function to define your application configuration.
- * Provides autocompletion and type-checking for contentstorage.config.js files.
- */
-export declare function defineConfig(config: AppConfig): AppConfig;

package/dist/helpers/defineConfig.js

@@ -1,19 +0,0 @@
-/**
- * Helper function to define your application configuration.
- * Provides autocompletion and type-checking for contentstorage.config.js files.
- */
-export function defineConfig(config) {
-    // You can add basic runtime validation here if desired,
-    // e.g., check if contentUrl is a valid URL format,
-    // or if languageCodes is not empty.
-    if (!config.languageCodes || config.languageCodes.length === 0) {
-        console.warn('Warning: languageCodes array is empty or missing in the configuration.');
-    }
-    if (!config.contentDir) {
-        // This would typically be a hard error, but defineConfig is more for type safety at edit time.
-        // Runtime validation (see point 3) is better for hard errors.
-        console.warn('Warning: contentDir is missing in the configuration.');
-    }
-    // ... other checks
-    return config;
-}