@contentstorage/core 0.3.16 → 0.3.17

package/dist/lib/contentManagement.d.ts

@@ -1,4 +1,4 @@
-import { ContentStructure, DotNotationPaths } from '../types.js';
+import { ContentStructure } from '../types.js';
 /**
  * Loads and sets the content for a specific language.
  * It will internally ensure the application configuration (for contentDir) is loaded.
@@ -15,4 +15,4 @@ export declare function setContentLanguage(contentJson: ContentStructure | null)
  * 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: DotNotationPaths, fallbackValue?: string): string | undefined;
+export declare function getText(pathString: keyof ContentStructure, fallbackValue?: string): string | undefined;

package/dist/lib/contentManagement.js

@@ -27,29 +27,37 @@ export function setContentLanguage(contentJson) {
  * 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(
+// The pathString is now a direct key of your (flattened) content structure.
+// TypeScript will provide autocompletion for these keys.
+pathString, fallbackValue) {
     if (!activeContent) {
-        const msg = `[Contentstorage] getText: Content not loaded (Path: "${String(pathString)}"). Ensure setContentLanguage() was called and completed successfully.`;
+        const msg = `[Contentstorage] getText: Content not loaded (Key: "${String(pathString)}"). Ensure setContentLanguage() was called and completed successfully.`;
         console.warn(msg);
         return fallbackValue;
     }
-    const keys = pathString.split('.');
-    let current = activeContent;
-    for (const key of keys) {
-        if (current && typeof current === 'object' && key in current) {
-            current = current[key];
+    // Direct lookup since activeContent is expected to be flat and pathString is a key.
+    // We use Object.prototype.hasOwnProperty.call for safer property checking.
+    if (Object.prototype.hasOwnProperty.call(activeContent, pathString)) {
+        // Since pathString is `keyof CustomContentStructure`, activeContent[pathString] is type-safe.
+        // However, CustomContentStructure is initially `[key: string]: any` in the library,
+        // so we might need a cast here if strict typing is desired for `value`.
+        // But the consumer's augmentation makes CustomContentStructure specific.
+        const value = activeContent[pathString]; // Using `as string` because keys are strings with dots.
+        if (typeof value === 'string') {
+            return value;
         }
         else {
-            const msg = `[Contentstorage] getText: Path "${String(pathString)}" not found in loaded content.`;
+            const msg = `[Contentstorage] getText: Value at key "${String(pathString)}" is not a string (actual type: ${typeof value}).'}'.`;
             console.warn(msg);
             return fallbackValue;
         }
     }
-    if (typeof current === 'string') {
-        return current;
-    }
     else {
-        const msg = `[Contentstorage] getText: Value at path "${String(pathString)}" is not a string (actual type: ${typeof current}).`;
+        // This case should ideally be caught by TypeScript if pathString is truly `keyof CustomContentStructure`
+        // and the key doesn't exist, unless `activeContent` is out of sync with the types.
+        // However, it's good for runtime robustness.
+        const msg = `[Contentstorage] getText: Key "${String(pathString)}" not found in loaded content'.`;
         console.warn(msg);
         return fallbackValue;
     }

package/dist/types.d.ts

@@ -23,17 +23,3 @@ export type LanguageCode = 'SQ' | 'BE' | 'BS' | 'BG' | 'HR' | 'CS' | 'DA' | 'NL'
 export interface ContentStructure {
     [key: string]: any;
 }
-type MaxPathDepth = [any, any, any, any, any, any];
-/**
- * Generates a union of all possible dot-notation path strings for a given object type `T`,
- * with a limit on recursion depth to prevent TypeScript errors.
- * Defaults to using the `CustomContentStructure` interface, which consumers augment.
- *
- * @template T The object type to generate paths from.
- * @template Prefix Internal accumulator for the current path prefix.
- * @template CurrentDepth Internal tuple to track recursion depth.
- */
-export type DotNotationPaths<T = ContentStructure, Prefix extends string = '', CurrentDepth extends any[] = []> = T extends object ? {
-    [K in keyof T & (string | number)]-?: CurrentDepth['length'] extends MaxPathDepth['length'] ? `${Prefix}${K}` : T[K] extends object ? `${Prefix}${K}` | DotNotationPaths<T[K], `${Prefix}${K}.`, [...CurrentDepth, any]> : `${Prefix}${K}`;
-}[keyof T & (string | number)] : never;
-export {};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@contentstorage/core",
   "author": "Kaido Hussar <kaidohus@gmail.com>",
   "homepage": "https://contentstorage.app",
-  "version": "0.3.16",
+  "version": "0.3.17",
   "type": "module",
   "description": "Fetch content from contentstorage and generate TypeScript types",
   "module": "dist/index.js",