@contentstorage/core 1.2.1 → 2.1.0

package/dist/commands/pull.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+import axios from 'axios';
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import { loadConfig } from '../core/config-loader.js';
+import { CONTENTSTORAGE_CONFIG } from '../utils/constants.js';
+export async function pullContent() {
+    console.log(chalk.blue('Starting content pull...'));
+    const args = process.argv.slice(2);
+    const cliConfig = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            const key = arg.substring(2);
+            const value = args[i + 1];
+            if (key === 'pending-changes') {
+                cliConfig.pendingChanges = true;
+            }
+            else if (value && !value.startsWith('--')) {
+                if (key === 'lang') {
+                    cliConfig.languageCodes = [value.toUpperCase()];
+                }
+                else if (key === 'content-key') {
+                    cliConfig.contentKey = value;
+                }
+                else if (key === 'content-dir') {
+                    cliConfig.contentDir = value;
+                }
+                // Skip the value in the next iteration
+                i++;
+            }
+        }
+    }
+    let fileConfig = {};
+    try {
+        fileConfig = await loadConfig();
+    }
+    catch {
+        console.log(chalk.yellow('Could not load a configuration file. Proceeding with CLI arguments.'));
+    }
+    const config = { ...fileConfig, ...cliConfig };
+    // Validate required fields
+    if (!config.contentKey) {
+        console.error(chalk.red('Error: Configuration is missing the required "contentKey" property.'));
+        process.exit(1);
+    }
+    if (!config.contentDir) {
+        console.error(chalk.red('Error: Configuration is missing the required "contentDir" property.'));
+        process.exit(1);
+    }
+    console.log(chalk.blue(`Content key: ${config.contentKey}`));
+    console.log(chalk.blue(`Saving content to: ${config.contentDir}`));
+    try {
+        // Validate languageCodes array
+        if (!Array.isArray(config.languageCodes)) {
+            console.log(chalk.red(`Expected array from config.languageCodes, but received type ${typeof config.languageCodes}. Cannot pull files.`));
+            return; // Exit if languageCodes is not an array
+        }
+        if (config.languageCodes.length === 0) {
+            console.log(chalk.yellow('config.languageCodes array is empty. No files to pull.'));
+            return; // Exit if languageCodes array is empty
+        }
+        // Ensure the output directory exists (create it once before the loop)
+        await fs.mkdir(config.contentDir, { recursive: true });
+        // Process each language code
+        for (const languageCode of config.languageCodes) {
+            let fileUrl;
+            const requestConfig = {};
+            if (config.pendingChanges) {
+                fileUrl = `${CONTENTSTORAGE_CONFIG.API_URL}/pending-changes/get-json?languageCode=${languageCode}`;
+                requestConfig.headers = {
+                    'X-Content-Key': config.contentKey,
+                };
+            }
+            else {
+                fileUrl = `${CONTENTSTORAGE_CONFIG.BASE_URL}/${config.contentKey}/content/${languageCode}.json`;
+            }
+            const filename = `${languageCode}.json`;
+            const outputPath = path.join(config.contentDir, filename);
+            console.log(chalk.blue(`\nProcessing language: ${languageCode}`));
+            console.log(chalk.blue(`Using following contentKey to fetch json: ${config.contentKey}`));
+            try {
+                // Fetch data for the current language
+                const response = await axios.get(fileUrl, requestConfig);
+                let jsonData = response.data;
+                // Handle API response structure - only for pending changes API
+                if (config.pendingChanges &&
+                    jsonData &&
+                    typeof jsonData === 'object' &&
+                    'data' in jsonData) {
+                    jsonData = jsonData.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 ${languageCode}.`);
+                }
+                // 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' ||
+                    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 JSON for ${languageCode}. Saving to ${outputPath}`));
+                await fs.writeFile(outputPath, JSON.stringify(jsonData, null, 2));
+                console.log(chalk.green(`Successfully saved ${outputPath}`));
+            }
+            catch (error) {
+                // Catch errors related to fetching or saving a single language file
+                console.error(chalk.red(`\nError processing language ${languageCode} from ${fileUrl}:`));
+                if (axios.isAxiosError(error)) {
+                    console.error(chalk.red(`  Status: ${error.response?.status}`));
+                    console.error(chalk.red(`Response Data: ${error.response?.data ? JSON.stringify(error.response.data) : 'N/A'}`));
+                    console.error(chalk.red(`  Message: ${error.message}`)); // Axios error message
+                }
+                else {
+                    // For non-Axios errors (e.g., manually thrown errors, fs errors)
+                    console.error(chalk.red(`  Error: ${error.message}`));
+                }
+                // Re-throw the error to be caught by the outer try-catch block,
+                // which will then call process.exit(1), maintaining original exit behavior on error.
+                throw error;
+            }
+        }
+        console.log(chalk.green('\nAll content successfully pulled and saved.'));
+    }
+    catch {
+        // Outer catch for setup errors (like loadConfig) or re-thrown errors from the loop
+        // The specific error details for a file operation would have been logged by the inner catch.
+        // This block provides a general failure message and ensures the process exits with an error code.
+        console.error(chalk.red('\n-----------------------------------------------------'));
+        console.error(chalk.red('Content pull failed due to an error. See details above.'));
+        // error.message from the re-thrown error will be implicitly part of the error object logged by some environments,
+        // or if you add console.error(error) here.
+        // The original code logged error.message at this level:
+        // if (error.message) console.error(chalk.red(`Underlying error: ${error.message}`));
+        console.error(chalk.red('-----------------------------------------------------'));
+        process.exit(1); // Exit with error code
+    }
+}

package/dist/commands/stats.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Main stats command function
+ */
+export declare function showStats(): Promise<void>;

package/dist/commands/stats.js

@@ -0,0 +1,268 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { loadConfig } from '../core/config-loader.js';
+import { flattenJson } from '../utils/flatten-json.js';
+import { CONTENTSTORAGE_CONFIG } from '../utils/constants.js';
+/**
+ * Check if a value is considered untranslated
+ */
+function isUntranslated(value) {
+    return value === '' || value === null || value === undefined;
+}
+/**
+ * Load content for a specific language, trying local files first, then API
+ */
+async function loadLanguageContent(languageCode, config) {
+    // Try local file first
+    try {
+        const filePath = path.join(config.contentDir, `${languageCode}.json`);
+        const content = await fs.readFile(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        // Fallback to API
+        console.log(chalk.dim(`Local file not found for ${languageCode}, fetching from API...`));
+        let fileUrl;
+        const requestConfig = {
+            timeout: 30000,
+        };
+        if (config.pendingChanges) {
+            fileUrl = `${CONTENTSTORAGE_CONFIG.API_URL}/pending-changes/get-json?languageCode=${languageCode}`;
+            requestConfig.headers = {
+                'X-Content-Key': config.contentKey,
+            };
+        }
+        else {
+            fileUrl = `${CONTENTSTORAGE_CONFIG.BASE_URL}/${config.contentKey}/content/${languageCode}.json`;
+        }
+        try {
+            const response = await axios.get(fileUrl, requestConfig);
+            let jsonData = response.data;
+            // Unwrap pending changes response
+            if (config.pendingChanges &&
+                jsonData &&
+                typeof jsonData === 'object' &&
+                'data' in jsonData) {
+                jsonData = jsonData.data;
+            }
+            return jsonData;
+        }
+        catch (apiError) {
+            console.error(chalk.red(`Failed to load content for ${languageCode}:`));
+            if (apiError.response) {
+                console.error(chalk.red(`  Status: ${apiError.response.status}`));
+            }
+            throw apiError;
+        }
+    }
+}
+/**
+ * Analyze a single language against a reference language
+ */
+function analyzeLanguage(languageCode, content, referenceContent) {
+    const flatContent = flattenJson(content);
+    const flatReference = flattenJson(referenceContent);
+    const untranslatedItems = [];
+    // Get all keys from reference
+    const allKeys = Object.keys(flatReference);
+    const totalItems = allKeys.length;
+    // Check each key
+    for (const key of allKeys) {
+        // Check if key is missing in target language
+        if (!(key in flatContent)) {
+            untranslatedItems.push({ key, reason: 'missing' });
+            continue;
+        }
+        // Check if value is empty
+        if (isUntranslated(flatContent[key])) {
+            untranslatedItems.push({ key, reason: 'empty' });
+        }
+    }
+    const untranslatedCount = untranslatedItems.length;
+    const translatedCount = totalItems - untranslatedCount;
+    const completionPercentage = totalItems > 0 ? (translatedCount / totalItems) * 100 : 100;
+    return {
+        languageCode,
+        total: totalItems,
+        translated: translatedCount,
+        untranslated: untranslatedCount,
+        completionPercentage,
+        untranslatedItems,
+    };
+}
+/**
+ * Display statistics in a formatted table
+ */
+function displayStats(result) {
+    console.log(chalk.bold('\n📊 Translation Statistics'));
+    console.log(chalk.dim('═'.repeat(70)));
+    // Reference language info
+    console.log(chalk.cyan(`\nReference Language: ${chalk.bold(result.referenceLanguage)} (baseline for comparison)`));
+    console.log(chalk.cyan(`Total unique content items: ${chalk.bold(result.totalItems)}`));
+    // Language statistics table header
+    console.log(chalk.bold('\n📋 Language Statistics:'));
+    console.log(chalk.dim('─'.repeat(70)));
+    // Table header
+    const headerFormat = (str, width) => str.padEnd(width, ' ');
+    console.log(chalk.bold(headerFormat('Language', 12) +
+        headerFormat('Total', 10) +
+        headerFormat('Translated', 13) +
+        headerFormat('Untranslated', 15) +
+        'Complete'));
+    console.log(chalk.dim('─'.repeat(70)));
+    // Language rows
+    for (const stats of result.languageStats) {
+        const percentageColor = stats.completionPercentage === 100
+            ? chalk.green
+            : stats.completionPercentage >= 80
+                ? chalk.yellow
+                : chalk.red;
+        const percentage = percentageColor(stats.completionPercentage.toFixed(1) + '%');
+        console.log(chalk.white(headerFormat(stats.languageCode, 12)) +
+            chalk.white(headerFormat(stats.total.toString(), 10)) +
+            chalk.white(headerFormat(stats.translated.toString(), 13)) +
+            (stats.untranslated > 0
+                ? chalk.red(headerFormat(stats.untranslated.toString(), 15))
+                : chalk.green(headerFormat(stats.untranslated.toString(), 15))) +
+            percentage);
+    }
+    console.log(chalk.dim('─'.repeat(70)));
+    // Untranslated items details
+    const languagesWithIssues = result.languageStats.filter((s) => s.untranslated > 0);
+    if (languagesWithIssues.length > 0) {
+        console.log(chalk.bold('\n⚠️  Untranslated Items by Language:'));
+        console.log(chalk.dim('─'.repeat(70)));
+        for (const stats of languagesWithIssues) {
+            console.log(chalk.yellow(`\n${stats.languageCode} (${stats.untranslated} ${stats.untranslated === 1 ? 'item' : 'items'}):`));
+            // Group by reason
+            const emptyItems = stats.untranslatedItems
+                .filter((item) => item.reason === 'empty')
+                .map((item) => item.key);
+            const missingItems = stats.untranslatedItems
+                .filter((item) => item.reason === 'missing')
+                .map((item) => item.key);
+            if (emptyItems.length > 0) {
+                console.log(chalk.dim('  Empty values:'));
+                emptyItems.forEach((key) => {
+                    console.log(chalk.red(`    • ${key}`));
+                });
+            }
+            if (missingItems.length > 0) {
+                console.log(chalk.dim('  Missing keys:'));
+                missingItems.forEach((key) => {
+                    console.log(chalk.red(`    • ${key}`));
+                });
+            }
+        }
+    }
+    else {
+        console.log(chalk.green('\n✅ All languages are fully translated!'));
+    }
+    // Overall completion
+    console.log(chalk.bold('\n📈 Overall Summary:'));
+    console.log(chalk.dim('─'.repeat(70)));
+    const overallColor = result.overallCompletion === 100
+        ? chalk.green
+        : result.overallCompletion >= 80
+            ? chalk.yellow
+            : chalk.red;
+    console.log(overallColor(`Overall Completion: ${chalk.bold(result.overallCompletion.toFixed(1) + '%')}`));
+    console.log('');
+}
+/**
+ * Main stats command function
+ */
+export async function showStats() {
+    try {
+        console.log(chalk.blue('Loading configuration...'));
+        // Parse CLI arguments
+        const args = process.argv.slice(2);
+        const cliConfig = {};
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (arg.startsWith('--')) {
+                const key = arg.substring(2);
+                if (key === 'pending-changes') {
+                    cliConfig.pendingChanges = true;
+                }
+                else {
+                    const value = args[i + 1];
+                    if (value && !value.startsWith('--')) {
+                        if (key === 'content-key') {
+                            cliConfig.contentKey = value;
+                        }
+                        else if (key === 'content-dir') {
+                            cliConfig.contentDir = value;
+                        }
+                        i++; // Skip the value in next iteration
+                    }
+                }
+            }
+        }
+        // Load config from file
+        let fileConfig = {};
+        try {
+            fileConfig = await loadConfig();
+        }
+        catch {
+            console.log(chalk.yellow('⚠️  Could not load a configuration file, using CLI arguments only'));
+        }
+        // Merge configurations (CLI args override file config)
+        const config = { ...fileConfig, ...cliConfig };
+        // Validate required fields
+        if (!config.contentKey) {
+            console.error(chalk.red('\n❌ Error: Content key is required. Provide it via config file or --content-key argument.'));
+            process.exit(1);
+        }
+        if (!config.languageCodes || config.languageCodes.length === 0) {
+            console.error(chalk.red('\n❌ Error: At least one language code is required in configuration.'));
+            process.exit(1);
+        }
+        // Set defaults
+        if (!config.contentDir) {
+            config.contentDir = 'src/content/json';
+        }
+        const fullConfig = config;
+        console.log(chalk.blue(`Analyzing ${fullConfig.languageCodes.length} language(s)...`));
+        // Load content for all languages
+        const languageContents = {};
+        for (const languageCode of fullConfig.languageCodes) {
+            try {
+                languageContents[languageCode] = await loadLanguageContent(languageCode, fullConfig);
+            }
+            catch {
+                console.error(chalk.red(`\n❌ Failed to load content for ${languageCode}`));
+                process.exit(1);
+            }
+        }
+        console.log(chalk.green('✓ All content loaded successfully\n'));
+        // Use first language as reference
+        const referenceLanguage = fullConfig.languageCodes[0];
+        const referenceContent = languageContents[referenceLanguage];
+        // Analyze each language
+        const languageStats = [];
+        for (const languageCode of fullConfig.languageCodes) {
+            const stats = analyzeLanguage(languageCode, languageContents[languageCode], referenceContent);
+            languageStats.push(stats);
+        }
+        // Calculate overall completion
+        const totalTranslated = languageStats.reduce((sum, s) => sum + s.translated, 0);
+        const totalPossible = languageStats.reduce((sum, s) => sum + s.total, 0);
+        const overallCompletion = totalPossible > 0 ? (totalTranslated / totalPossible) * 100 : 100;
+        const result = {
+            referenceLanguage,
+            totalItems: Object.keys(flattenJson(referenceContent)).length,
+            languageStats,
+            overallCompletion,
+        };
+        // Display results
+        displayStats(result);
+    }
+    catch (error) {
+        console.error(chalk.red('\n❌ An error occurred:'));
+        console.error(chalk.red(error.message || error));
+        process.exit(1);
+    }
+}

package/dist/core/config-loader.d.ts

@@ -0,0 +1,2 @@
+import { AppConfig } from '../types.js';
+export declare function loadConfig(): Promise<AppConfig>;

package/dist/core/config-loader.js

@@ -0,0 +1,42 @@
+import path from 'path';
+import fs from 'fs';
+import chalk from 'chalk';
+const DEFAULT_CONFIG = {
+    languageCodes: [],
+    contentDir: path.join('src', 'content', 'json'),
+    typesOutputFile: path.join('src', 'content', 'content-types.ts'),
+};
+export async function loadConfig() {
+    const configPath = path.resolve(process.cwd(), 'contentstorage.config.js'); // Look in user's current working dir
+    let userConfig = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            // Use require for JS config file
+            const loadedModule = await import(configPath);
+            userConfig = loadedModule.default || loadedModule;
+            console.log(chalk.blue('Loaded config', JSON.stringify(userConfig)));
+            console.log(chalk.blue(`Loaded configuration from ${configPath}`));
+        }
+        catch (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(chalk.yellow('Proceeding with default configuration.'));
+            userConfig = {}; // Reset in case of partial load failure
+        }
+    }
+    else {
+        console.log(chalk.blue('No content.config.js found. Continuing.'));
+    }
+    const mergedConfig = {
+        ...DEFAULT_CONFIG,
+        ...userConfig,
+    };
+    const finalConfig = {
+        languageCodes: mergedConfig.languageCodes || [],
+        contentKey: mergedConfig.contentKey || '',
+        contentDir: path.resolve(process.cwd(), mergedConfig.contentDir),
+        typesOutputFile: path.resolve(process.cwd(), mergedConfig.typesOutputFile),
+    };
+    return finalConfig;
+}

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

@@ -1,7 +1,7 @@
 // @ts-expect-error
-import * as pluralize from "pluralize";
-import { TypeGroup } from './model.js';
-import { findTypeById, getTypeDescriptionGroup, isHash, parseKeyMetaData } from './util.js';
+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
 ) {
@@ -34,7 +34,7 @@ function getName({ rootTypeId, types }, keyName, names, isInsideArray
             };
     }
 }
-export function getNames(typeStructure, rootName = "RootObject") {
+export function getNames(typeStructure, rootName = 'RootObject') {
     return getName(typeStructure, rootName, [], false).names.reverse();
 }
 function getNameById(id, keyName, isInsideArray, types, nameMap) {
@@ -47,7 +47,9 @@ function getNameById(id, keyName, isInsideArray, types, nameMap) {
     let name;
     switch (group) {
         case TypeGroup.Array:
-            name = typeDesc.isUnion ? getArrayName(typeDesc, types, nameMap) : formatArrayName(typeDesc, types, nameMap);
+            name = typeDesc.isUnion
+                ? getArrayName(typeDesc, types, nameMap)
+                : formatArrayName(typeDesc, types, nameMap);
             break;
         case TypeGroup.Object:
             /**
@@ -72,9 +74,9 @@ function getNameById(id, keyName, isInsideArray, types, nameMap) {
 function pascalCase(name) {
     return name
         .split(/\s+/g)
-        .filter((_) => _ !== "")
+        .filter((_) => _ !== '')
         .map(capitalize)
-        .reduce((a, b) => a + b, "");
+        .reduce((a, b) => a + b, '');
 }
 function capitalize(name) {
     return name.charAt(0).toUpperCase() + name.slice(1);
@@ -84,7 +86,7 @@ function normalizeInvalidTypeName(name) {
         return name;
     }
     else {
-        const noSymbolsName = name.replace(/[^a-zA-Z0-9]/g, "");
+        const noSymbolsName = name.replace(/[^a-zA-Z0-9]/g, '');
         const startsWithWordCharacter = /^[a-zA-Z]/.test(noSymbolsName);
         return startsWithWordCharacter ? noSymbolsName : `_${noSymbolsName}`;
     }
@@ -100,9 +102,10 @@ function uniqueByIncrement(name, names) {
 function getArrayName(typeDesc, types, nameMap) {
     // @ts-ignore
     if (typeDesc.arrayOfTypes.length === 0) {
-        return "any";
+        return 'any';
     }
-    else { // @ts-ignore
+    else {
+        // @ts-ignore
         if (typeDesc.arrayOfTypes.length === 1) {
             // @ts-ignore
             const [idOrPrimitive] = typeDesc.arrayOfTypes;
@@ -125,7 +128,7 @@ function unionToString(typeDesc, types, nameMap) {
     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

package/dist/type-generation/util.js

@@ -6,30 +6,30 @@ export function onlyUnique(value, index, self) {
     return self.indexOf(value) === index;
 }
 export function isArray(x) {
-    return Object.prototype.toString.call(x) === "[object Array]";
+    return Object.prototype.toString.call(x) === '[object Array]';
 }
 export function isNonArrayUnion(typeName) {
     const arrayUnionRegex = /^\(.*\)\[\]$/;
-    return typeName.includes(" | ") && !arrayUnionRegex.test(typeName);
+    return typeName.includes(' | ') && !arrayUnionRegex.test(typeName);
 }
 export function isObject(x) {
-    return Object.prototype.toString.call(x) === "[object Object]" && x !== null;
+    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("--?");
+    const isOptional = key.endsWith('--?');
     if (isOptional) {
         return {
             isOptional,
-            keyValue: key.slice(0, -3)
+            keyValue: key.slice(0, -3),
         };
     }
     else {
         return {
             isOptional,
-            keyValue: key
+            keyValue: key,
         };
     }
 }
@@ -45,5 +45,5 @@ export function getTypeDescriptionGroup(desc) {
     }
 }
 export function findTypeById(id, types) {
-    return types.find(_ => _.id === id);
+    return types.find((_) => _.id === id);
 }

package/dist/types.d.ts

@@ -15,27 +15,3 @@ export type LanguageCode = 'SQ' | 'BE' | 'BS' | 'BG' | 'HR' | 'CS' | 'DA' | 'NL'
  */
 export interface ContentStructure {
 }
-export type GetTextReturn = {
-    contentId: string;
-    text: string;
-};
-export type GetImageReturn = {
-    contentId: string;
-    data: ImageObject;
-};
-export type GetVariationReturn = {
-    contentId: string;
-    text: string;
-};
-export interface ImageObject {
-    contentstorage_type: 'image';
-    url: string;
-    altText: string;
-}
-export interface VariationData {
-    [key: string]: string;
-}
-export interface VariationObject {
-    contentstorage_type: 'variation';
-    data: VariationData;
-}

package/dist/utils/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const CONTENTSTORAGE_CONFIG: {
+    BASE_URL: string;
+    API_URL: string;
+};

package/dist/utils/constants.js

@@ -0,0 +1,4 @@
+export const CONTENTSTORAGE_CONFIG = {
+    BASE_URL: 'https://cdn.contentstorage.app',
+    API_URL: 'https://api.contentstorage.app',
+};

package/dist/utils/flatten-json.d.ts

@@ -0,0 +1 @@
+export declare function flattenJson(data: any, prefix?: string, result?: Record<string, any>): Record<string, any>;

package/dist/utils/flatten-json.js

@@ -0,0 +1,56 @@
+export function flattenJson(data, prefix = '', result = {}) {
+    const stopFlatteningIfKeyExists = 'contentstorage_type';
+    // Check if the current data is an object that should not be flattened further
+    if (typeof data === 'object' &&
+        data !== null &&
+        !Array.isArray(data) && // Must be an object, not an array
+        Object.prototype.hasOwnProperty.call(data, stopFlatteningIfKeyExists)) {
+        if (prefix) {
+            // If there's a prefix, this object is nested. Assign it directly.
+            result[prefix] = data;
+        }
+        else {
+            // This is the root object itself having the 'stopFlatteningIfKeyExists' key.
+            // Consistent with how root primitives are handled (result remains empty),
+            // we don't add it to the result if there's no prefix. The function's
+            // purpose is to flatten *into* key-value pairs. If the root itself
+            // is one of these "don't flatten" types, 'result' will remain empty,
+            // which is consistent with the original function's behavior for root primitives.
+        }
+    }
+    else if (typeof data === 'object' && data !== null) {
+        // It's an object or array that should be processed further
+        if (Array.isArray(data)) {
+            if (data.length === 0 && prefix) {
+                // Handle empty arrays if prefix exists
+                result[prefix] = [];
+            }
+            data.forEach((item, index) => {
+                // Recursively call, the check for 'stopFlatteningIfKeyExists' will apply to 'item'
+                flattenJson(item, prefix ? `${prefix}.${index}` : `${index}`, result);
+            });
+        }
+        else {
+            let isEmptyObject = true;
+            for (const key in data) {
+                if (Object.prototype.hasOwnProperty.call(data, key)) {
+                    isEmptyObject = false;
+                    const newPrefix = prefix ? `${prefix}.${key}` : key;
+                    // Recursively call, the check for 'stopFlatteningIfKeyExists' will apply to 'data[key]'
+                    flattenJson(data[key], newPrefix, result);
+                }
+            }
+            if (isEmptyObject && prefix) {
+                // Handle empty objects (that were not 'special') if prefix exists
+                result[prefix] = {};
+            }
+        }
+    }
+    else if (prefix) {
+        result[prefix] = data;
+    }
+    // If the initial data is a primitive and prefix is empty, result remains empty.
+    // If the initial data is a 'special' object (contains 'stopFlatteningIfKeyExists')
+    // and prefix is empty, result also remains empty based on the logic above.
+    return result;
+}