aimeat 1.33.2 → 1.35.0

package/dist/public/cortex-bundled/aimeat-i18n.js

@@ -0,0 +1,123 @@
+/**
+ * @file aimeat-i18n.js
+ * @description Bundled cortex library: lightweight i18n/localization helper for AIMEAT apps.
+ *   Wraps translation loading (inline or from the user's own memory — translations are USER
+ *   data), a flat-key-first `t()` with {var} interpolation, locale switching with persistence,
+ *   a daisyUI-friendly LanguageSwitcher, and a data-i18n DOM applier. No backend, no hard deps;
+ *   uses AIMEAT.data when present to load translations from memory.
+ * @structure AIMEAT.i18n.{init,t,setLocale,getLocale,locales,available,LanguageSwitcher,apply}
+ * @version-history
+ *   v1.0.0 — 2026-06-26 — Initial: inline + memory-backed translations, switcher, DOM applier.
+ */
+(function (AIMEAT) {
+  'use strict';
+
+  var state = { keyBase: null, localeList: [], locale: 'en', dicts: {}, fallback: 'en' };
+  var STORE_KEY = 'aimeat-i18n-locale';
+  var styled = false;
+
+  function injectStyles() {
+    if (styled) return; styled = true;
+    var css =
+      '.aui-i18n-select{font-family:"DM Sans",system-ui,sans-serif;font-size:.875rem;' +
+      'padding:.35rem .6rem;border-radius:var(--radius-xs,6px);border:1px solid var(--border,#E5E7EB);' +
+      'background:var(--bg-card,#fff);color:var(--text,#1A1A2E);cursor:pointer;}';
+    var s = document.createElement('style'); s.setAttribute('data-aimeat', 'i18n'); s.textContent = css;
+    document.head.appendChild(s);
+  }
+
+  function getPath(obj, path) {
+    var parts = String(path).split('.'); var o = obj;
+    for (var i = 0; i < parts.length; i++) { if (o == null) return null; o = o[parts[i]]; }
+    return o;
+  }
+  function interpolate(str, vars) {
+    if (!vars) return str;
+    return str.replace(/\{(\w+)\}/g, function (m, k) { return (vars[k] != null) ? vars[k] : m; });
+  }
+
+  // Load a single locale's dictionary: inline first, then the user's memory (USER data).
+  function loadDict(locale) {
+    if (state.dicts[locale]) return Promise.resolve(state.dicts[locale]);
+    if (state.keyBase && AIMEAT.data && typeof AIMEAT.data.get === 'function') {
+      return Promise.resolve(AIMEAT.data.get(state.keyBase + '.' + locale))
+        .then(function (v) { if (v && typeof v === 'object') state.dicts[locale] = v; return state.dicts[locale] || {}; })
+        .catch(function () { return {}; });
+    }
+    return Promise.resolve({});
+  }
+
+  /**
+   * init({ keyBase?, locales, default?, fallback?, translations? })
+   *  - translations: optional inline map { en:{...}, fi:{...} } (used as-is, no memory read)
+   *  - keyBase: memory key prefix; locale dicts read from `${keyBase}.${locale}` via AIMEAT.data
+   */
+  function init(opts) {
+    opts = opts || {};
+    state.keyBase = opts.keyBase || null;
+    state.localeList = opts.locales || (opts.translations ? Object.keys(opts.translations) : ['en']);
+    state.fallback = opts.fallback || opts.default || state.localeList[0] || 'en';
+    if (opts.translations) state.dicts = Object.assign({}, opts.translations);
+    var saved = null;
+    try { saved = window.localStorage.getItem(STORE_KEY); } catch (e) { /* private mode */ }
+    state.locale = (saved && state.localeList.indexOf(saved) !== -1) ? saved : (opts.default || state.fallback);
+    return loadDict(state.locale).then(function () { return state.locale; });
+  }
+
+  function t(key, vars) {
+    var d = state.dicts[state.locale] || {};
+    var raw = (d[key] != null) ? d[key] : getPath(d, key);
+    if (raw == null) {
+      var fb = state.dicts[state.fallback] || {};
+      raw = (fb[key] != null) ? fb[key] : getPath(fb, key);
+    }
+    if (raw == null) raw = key;
+    return interpolate(String(raw), vars);
+  }
+
+  function setLocale(locale) {
+    if (state.localeList.indexOf(locale) === -1) return Promise.resolve(state.locale);
+    return loadDict(locale).then(function () {
+      state.locale = locale;
+      try { window.localStorage.setItem(STORE_KEY, locale); } catch (e) { /* ignore */ }
+      try { window.dispatchEvent(new CustomEvent('aimeat-i18n-changed', { detail: { locale: locale } })); } catch (e) { /* ignore */ }
+      return locale;
+    });
+  }
+
+  function getLocale() { return state.locale; }
+  function locales() { return state.localeList.slice(); }
+  function available() { return state.localeList.length > 0; }
+
+  // Translate every [data-i18n] element in root (textContent). Optional [data-i18n-attr].
+  function apply(root) {
+    var scope = root || document;
+    var nodes = scope.querySelectorAll('[data-i18n]');
+    for (var i = 0; i < nodes.length; i++) {
+      var n = nodes[i]; var key = n.getAttribute('data-i18n');
+      var attr = n.getAttribute('data-i18n-attr');
+      if (attr) n.setAttribute(attr, t(key)); else n.textContent = t(key);
+    }
+  }
+
+  function LanguageSwitcher(opts) {
+    opts = opts || {}; injectStyles();
+    var sel = document.createElement('select');
+    sel.className = 'aui-i18n-select ' + (opts.className || '');
+    state.localeList.forEach(function (loc) {
+      var o = document.createElement('option'); o.value = loc; o.textContent = (opts.labels && opts.labels[loc]) || loc.toUpperCase();
+      if (loc === state.locale) o.selected = true; sel.appendChild(o);
+    });
+    sel.addEventListener('change', function () {
+      setLocale(sel.value).then(function (loc) { if (typeof opts.onChange === 'function') opts.onChange(loc); });
+    });
+    if (opts.target) {
+      var tgt = (typeof opts.target === 'string') ? document.querySelector(opts.target) : opts.target;
+      if (tgt) tgt.appendChild(sel);
+    }
+    return { el: sel, destroy: function () { if (sel.parentNode) sel.parentNode.removeChild(sel); } };
+  }
+
+  AIMEAT.i18n = { init: init, t: t, setLocale: setLocale, getLocale: getLocale, locales: locales, available: available, LanguageSwitcher: LanguageSwitcher, apply: apply };
+  AIMEAT['aimeat-i18n'] = AIMEAT.i18n;
+})(window.AIMEAT || (window.AIMEAT = {}));

package/dist/public/cortex-bundled/aimeat-i18n.yaml

@@ -0,0 +1,64 @@
+apiVersion: cortex.aimeat.org/v1
+kind: Extension
+metadata:
+  name: aimeat-i18n
+  namespace: aimeat
+  description: "Localization helper — load translations (inline or from the user's own memory), translate with flat-key-first t() + {var} interpolation, switch locale with persistence, and a LanguageSwitcher UI."
+  author: AIMEAT
+  tags: [i18n, localization, translation, locale, multilanguage, components]
+  labels:
+    domain: i18n
+  visibility: public
+
+spec:
+  version: "1.0.0"
+  license: MIT
+  components:
+    - type: prompt
+      name: i18n-assistant
+      content: |
+        You are helping build an app that has the aimeat-i18n cortex installed.
+        Use AIMEAT.i18n for ALL user-visible text — never hardcode display strings.
+
+        Setup (once, at boot):
+          await AIMEAT.i18n.init({
+            locales: ['en', 'fi'],
+            default: 'en',
+            // EITHER inline translations:
+            translations: { en: { 'greeting': 'Hello {name}' }, fi: { 'greeting': 'Hei {name}' } }
+            // OR memory-backed (translations are USER data): keyBase: 'myapp.i18n'
+            //   → reads `myapp.i18n.en`, `myapp.i18n.fi` via AIMEAT.data.get()
+          });
+
+        Translate:
+          AIMEAT.i18n.t('greeting', { name: 'Alice' })   // flat key first, then nested dot-path, then fallback locale, then the key itself
+          // Flat keys win: a generator producing { "tab.search": "Haku" } resolves before a nested { tab: { search } }.
+
+        Switch language:
+          AIMEAT.i18n.LanguageSwitcher({ target: '#lang', onChange: render })   // renders a <select>; persists choice
+          AIMEAT.i18n.setLocale('fi')                                            // emits window 'aimeat-i18n-changed'
+          window.addEventListener('aimeat-i18n-changed', render)                 // re-render on change
+
+        Static markup:
+          <span data-i18n="greeting"></span>  then  AIMEAT.i18n.apply()          // fills textContent of every [data-i18n]
+
+        Notes:
+          - Translations are USER data — load them via AIMEAT.data (keyBase), NOT from an ext: namespace.
+          - t() always returns a string (falls back to the key) so the UI never shows blanks.
+        Load via: <script src="{{node_url}}/v1/cortex/aimeat-i18n/libs/aimeat-i18n.js"></script>
+      variables:
+        - "{{node_url}}"
+
+    - type: lib
+      name: aimeat-i18n
+      filename: aimeat-i18n.js
+      exports: [init, t, setLocale, getLocale, locales, available, LanguageSwitcher, apply]
+      api_surface: |
+        AIMEAT.i18n.init({ keyBase?, locales, default?, fallback?, translations? }) → Promise<locale>  (inline translations OR memory-backed via keyBase)
+        AIMEAT.i18n.t(key, vars?) → string  (flat key → nested dot-path → fallback locale → key; {var} interpolation)
+        AIMEAT.i18n.setLocale(locale) → Promise<locale>  (persists choice; emits window 'aimeat-i18n-changed')
+        AIMEAT.i18n.getLocale() → string
+        AIMEAT.i18n.locales() → string[]
+        AIMEAT.i18n.available() → boolean
+        AIMEAT.i18n.LanguageSwitcher({ target?, onChange?, labels?, className? }) → { el, destroy() }
+        AIMEAT.i18n.apply(root?) → void  (translates every [data-i18n] element's textContent, or [data-i18n-attr])

package/dist/public/css/views/landing.css

@@ -31,6 +31,8 @@
 .ld-hero2-sub { color: var(--text-dim); font-size: 1rem; max-width: 560px; margin: 1rem auto .25rem; }
 .ld-hero2-cta { display: flex; gap: .8rem; justify-content: center; flex-wrap: wrap; margin-top: 1.1rem; }
 .ld-hero2-cta a { text-decoration: none; }
+.ld-hero2-after { color: var(--text-dim); font-size: .9rem; max-width: 560px; margin: .9rem auto 0; }
+.ld-hero2-after a { color: var(--accent); font-weight: 600; }
 .ld-hero { text-align: center; padding: 2.5rem 0 1.25rem; }
 .ld-h1 { font-size: 2.1rem; font-weight: 800; letter-spacing: -0.5px; margin: 0 0 .6rem; }
 .ld-hero-sub { color: var(--text-dim); font-size: 1.05rem; margin: 0; }