@contentstorage/core 0.3.21 → 0.3.23

package/dist/lib/contentManagement.d.ts

@@ -16,3 +16,20 @@ export declare function setContentLanguage(contentJson: object): void;
  * @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 class CsText extends HTMLElement {
+    private _id;
+    private _keyForGetText;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    get idKey(): string | null;
+    set idKey(value: string | null);
+    /**
+     * Handles cases where properties might be set on the element before it's upgraded.
+     * Ensures initial attribute values are processed.
+     */
+    private upgradeProperties;
+    private updateText;
+}

package/dist/lib/contentManagement.js

@@ -43,22 +43,117 @@ pathString, fallbackValue) {
         // 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;
+        const keys = pathString.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.`;
+                console.warn(msg);
+                return fallbackValue;
+            }
+        }
+        if (typeof current === 'string') {
+            return current;
         }
         else {
-            const msg = `[Contentstorage] getText: Value at key "${String(pathString)}" is not a string (actual type: ${typeof value}).'}'.`;
+            const msg = `[Contentstorage] getText: Value at path "${String(pathString)}" is not a string (actual type: ${typeof current}).`;
             console.warn(msg);
             return fallbackValue;
         }
     }
     else {
-        // 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;
     }
 }
+// Ensure getText and potentially ContentStructure are imported or available in the scope.
+// For this example, let's assume they are, along with activeContent.
+// import { getText, ContentStructure, activeContent } from './contentStorage'; // Adjust path as needed
+// Placeholder for ContentStructure if not already globally available for the cast
+// This would ideally be the same ContentStructure interface your getText function uses.
+export class CsText extends HTMLElement {
+    static get observedAttributes() {
+        // Define which attributes to observe for changes.
+        return ['data-contentstorage-id'];
+    }
+    constructor() {
+        super();
+        this._id = null;
+        // You can attach a Shadow DOM here if you need style encapsulation:
+        // this.attachShadow({ mode: 'open' });
+        // For simplicity, this example will manipulate the light DOM (this.textContent).
+    }
+    connectedCallback() {
+        // Called when the element is added to the document's DOM.
+        this.upgradeProperties();
+        this.updateText();
+    }
+    disconnectedCallback() {
+        // Called when the element is removed from the document's DOM.
+        // Perform any necessary cleanup here (e.g., remove event listeners if any were added).
+    }
+    attributeChangedCallback(name, oldValue, newValue) {
+        // Called when one of the observed attributes changes.
+        let shouldUpdate = false;
+        if (name === 'data-contentstorage-id' && oldValue !== newValue) {
+            this._id = newValue;
+            // Important: The string from the attribute needs to be treated as keyof ContentStructure.
+            // This cast assumes the provided ID string is a valid key.
+            // Runtime validation against available keys in `activeContent` could be added for robustness.
+            this._keyForGetText = newValue;
+            shouldUpdate = true;
+        }
+        if (shouldUpdate) {
+            this.updateText();
+        }
+    }
+    // Property getters/setters (optional, but good practice if you want to interact via JS properties)
+    get idKey() {
+        return this._id;
+    }
+    set idKey(value) {
+        this._id = value;
+        this._keyForGetText = value; // Cast here as well
+        if (value === null) {
+            this.removeAttribute('data-contentstorage-id');
+        }
+        else {
+            this.setAttribute('data-contentstorage-id', value);
+        }
+        // Note: setAttribute will trigger attributeChangedCallback if observed.
+    }
+    /**
+     * Handles cases where properties might be set on the element before it's upgraded.
+     * Ensures initial attribute values are processed.
+     */
+    upgradeProperties() {
+        // Check if properties were set before upgrade by checking attributes.
+        if (!this._id && this.hasAttribute('data-contentstorage-id')) {
+            this._id = this.getAttribute('data-contentstorage-id');
+            this._keyForGetText = this._id;
+        }
+    }
+    updateText() {
+        if (!this.isConnected) {
+            // Don't try to update if the element isn't in the DOM.
+            return;
+        }
+        if (this._keyForGetText) {
+            const textValue = getText(this._keyForGetText);
+            this.textContent = textValue !== undefined ? textValue : '';
+        }
+        else {
+            // No ID provided.
+            this.textContent = '';
+        }
+    }
+}
+// Define the custom element for the browser to use.
+// Ensure this is called only once.
+if (typeof window !== 'undefined' && !customElements.get('cs-text')) {
+    customElements.define('cs-text', CsText);
+}

package/package.json

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

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;
-}