cumstack 1.0.0

package/src/app/shared/language-codes.js

@@ -0,0 +1,199 @@
+// iso 639-1 language code lookup table
+// maps 2-letter language codes to their native names
+
+export const LANGUAGE_CODES = {
+  aa: 'Afaraf',
+  ab: 'Аҧсуа',
+  ae: 'Avesta',
+  af: 'Afrikaans',
+  ak: 'Akan',
+  am: 'አማርኛ',
+  an: 'Aragonés',
+  ar: 'العربية',
+  as: 'অসমীয়া',
+  av: 'Авар',
+  ay: 'Aymar',
+  az: 'Azərbaycan',
+  ba: 'Башҡорт',
+  be: 'Беларуская',
+  bg: 'Български',
+  bh: 'भोजपुरी',
+  bi: 'Bislama',
+  bm: 'Bamanankan',
+  bn: 'বাংলা',
+  bo: 'བོད་ཡིག',
+  br: 'Brezhoneg',
+  bs: 'Bosanski',
+  ca: 'Català',
+  ce: 'Нохчийн',
+  ch: 'Chamoru',
+  co: 'Corsu',
+  cr: 'ᓀᐦᐃᔭᐍᐏᐣ',
+  cs: 'Čeština',
+  cu: 'Словѣньскъ',
+  cv: 'Чӑваш',
+  cy: 'Cymraeg',
+  da: 'Dansk',
+  de: 'Deutsch',
+  dv: 'ދިވެހި',
+  dz: 'རྫོང་ཁ',
+  ee: 'Eʋegbe',
+  el: 'Ελληνικά',
+  en: 'English',
+  eo: 'Esperanto',
+  es: 'Español',
+  et: 'Eesti',
+  eu: 'Euskara',
+  fa: 'فارسی',
+  ff: 'Fulfulde',
+  fi: 'Suomi',
+  fj: 'Vosa Vakaviti',
+  fo: 'Føroyskt',
+  fr: 'Français',
+  fy: 'Frysk',
+  ga: 'Gaeilge',
+  gd: 'Gàidhlig',
+  gl: 'Galego',
+  gn: "Avañe'ẽ",
+  gu: 'ગુજરાતી',
+  gv: 'Gaelg',
+  ha: 'هَوُسَ',
+  he: 'עברית',
+  hi: 'हिन्दी',
+  ho: 'Hiri Motu',
+  hr: 'Hrvatski',
+  ht: 'Kreyòl',
+  hu: 'Magyar',
+  hy: 'Հայերեն',
+  hz: 'Otjiherero',
+  ia: 'Interlingua',
+  id: 'Bahasa Indonesia',
+  ie: 'Interlingue',
+  ig: 'Igbo',
+  ii: 'ꆈꌠꉙ',
+  ik: 'Iñupiatun',
+  io: 'Ido',
+  is: 'Íslenska',
+  it: 'Italiano',
+  iu: 'ᐃᓄᒃᑎᑐᑦ',
+  ja: '日本語',
+  jv: 'Basa Jawa',
+  ka: 'ქართული',
+  kg: 'Kikongo',
+  ki: 'Gĩkũyũ',
+  kj: 'Kuanyama',
+  kk: 'Қазақша',
+  kl: 'Kalaallisut',
+  km: 'ភាសាខ្មែរ',
+  kn: 'ಕನ್ನಡ',
+  ko: '한국어',
+  kr: 'Kanuri',
+  ks: 'कश्मीरी',
+  ku: 'Kurdî',
+  kv: 'Коми',
+  kw: 'Kernewek',
+  ky: 'Кыргызча',
+  la: 'Latina',
+  lb: 'Lëtzebuergesch',
+  lg: 'Luganda',
+  li: 'Limburgs',
+  ln: 'Lingála',
+  lo: 'ລາວ',
+  lt: 'Lietuvių',
+  lu: 'Tshiluba',
+  lv: 'Latviešu',
+  mg: 'Malagasy',
+  mh: 'Kajin M̧ajeļ',
+  mi: 'Te Reo Māori',
+  mk: 'Македонски',
+  ml: 'മലയാളം',
+  mn: 'Монгол',
+  mr: 'मराठी',
+  ms: 'Bahasa Melayu',
+  mt: 'Malti',
+  my: 'ဗမာစာ',
+  na: 'Dorerin Naoero',
+  nb: 'Norsk Bokmål',
+  nd: 'isiNdebele',
+  ne: 'नेपाली',
+  ng: 'Owambo',
+  nl: 'Nederlands',
+  nn: 'Norsk Nynorsk',
+  no: 'Norsk',
+  nr: 'isiNdebele',
+  nv: 'Diné bizaad',
+  ny: 'ChiCheŵa',
+  oc: 'Occitan',
+  oj: 'ᐊᓂᔑᓈᐯᒧᐎᓐ',
+  om: 'Oromoo',
+  or: 'ଓଡ଼ିଆ',
+  os: 'Ирон',
+  pa: 'ਪੰਜਾਬੀ',
+  pi: 'पाऴि',
+  pl: 'Polski',
+  ps: 'پښتو',
+  pt: 'Português',
+  qu: 'Runa Simi',
+  rm: 'Rumantsch',
+  rn: 'Ikirundi',
+  ro: 'Română',
+  ru: 'Русский',
+  rw: 'Ikinyarwanda',
+  sa: 'संस्कृतम्',
+  sc: 'Sardu',
+  sd: 'سنڌي',
+  se: 'Davvisámegiella',
+  sg: 'Sängö',
+  si: 'සිංහල',
+  sk: 'Slovenčina',
+  sl: 'Slovenščina',
+  sm: 'Gagana Samoa',
+  sn: 'chiShona',
+  so: 'Soomaali',
+  sq: 'Shqip',
+  sr: 'Српски',
+  ss: 'SiSwati',
+  st: 'Sesotho',
+  su: 'Basa Sunda',
+  sv: 'Svenska',
+  sw: 'Kiswahili',
+  ta: 'தமிழ்',
+  te: 'తెలుగు',
+  tg: 'Тоҷикӣ',
+  th: 'ไทย',
+  ti: 'ትግርኛ',
+  tk: 'Türkmençe',
+  tl: 'Tagalog',
+  tn: 'Setswana',
+  to: 'Lea Faka-Tonga',
+  tr: 'Türkçe',
+  ts: 'Xitsonga',
+  tt: 'Татарча',
+  tw: 'Twi',
+  ty: 'Reo Tahiti',
+  ug: 'ئۇيغۇرچە',
+  uk: 'Українська',
+  ur: 'اردو',
+  uz: 'Oʻzbekcha',
+  ve: 'Tshivenḓa',
+  vi: 'Tiếng Việt',
+  vo: 'Volapük',
+  wa: 'Walon',
+  wo: 'Wolof',
+  xh: 'isiXhosa',
+  yi: 'ייִדיש',
+  yo: 'Yorùbá',
+  za: 'Saɯ cueŋƅ',
+  zh: '中文',
+  zu: 'isiZulu',
+};
+
+// check if language code is valid
+export function isValidLanguageCode(code) {
+  return code.length === 2 && LANGUAGE_CODES.hasOwnProperty(code);
+}
+
+// get native name for language code
+export function getLanguageName(code) {
+  return LANGUAGE_CODES[code] || code;
+}

package/src/app/shared/reactivity.js

@@ -0,0 +1,259 @@
+/**
+ * cumstack Reactivity System
+ * signal-based fine-grained reactivity (shared between client and server)
+ */
+
+let currentEffect = null;
+const effectStack = [];
+let batchDepth = 0;
+let pending = null;
+let schedule = null;
+
+/**
+ *  create a reactive signal
+ * @template T
+ * @param {T} initial - Initial value
+ * @returns {[() => T, (next: T | ((prev: T) => T)) => void]} Tuple of [getter, setter]
+ */
+export function createMoan(initial) {
+  let value = initial;
+  const subscribers = new Set();
+  const read = () => {
+    if (currentEffect) subscribers.add(currentEffect);
+    return value;
+  };
+  const write = (next) => {
+    const newValue = typeof next === 'function' ? next(value) : next;
+    if (Object.is(value, newValue)) return;
+    value = newValue;
+    const effects = [...subscribers];
+    for (const effect of effects) if (subscribers.has(effect)) (schedule || ((e) => e()))(effect);
+  };
+  return [read, write];
+}
+
+/**
+ * create an effect that runs when dependencies change
+ * @param {() => void} fn - Effect function
+ * @returns {() => void} Dispose function to stop the effect
+ */
+export function onClimax(fn) {
+  let disposed = false;
+  const cleanup = [];
+  const effect = () => {
+    if (disposed) return;
+    effectStack.push(effect);
+    currentEffect = effect;
+    try {
+      // run any previous cleanup
+      cleanup.forEach((c) => c());
+      cleanup.length = 0;
+      const result = fn();
+      if (typeof result === 'function') cleanup.push(result);
+    } catch (err) {
+      console.error('Effect error:', err);
+    } finally {
+      effectStack.pop();
+      currentEffect = effectStack[effectStack.length - 1] || null;
+    }
+  };
+  batch(effect);
+  return () => {
+    disposed = true;
+    cleanup.forEach((c) => c());
+    cleanup.length = 0;
+  };
+}
+
+/**
+ * create a computed value
+ * @template T
+ * @param {() => T} fn - Computation function
+ * @returns {() => T} Getter for the computed value
+ */
+export function knotMemo(fn) {
+  let initialized = false;
+  let cached;
+  const [signal, setSignal] = createMoan();
+  onClimax(() => {
+    const result = fn();
+    if (!initialized || !Object.is(result, cached)) {
+      cached = result;
+      untrack(() => batch(() => setSignal(result)));
+      initialized = true;
+    }
+  });
+  return signal;
+}
+
+/**
+ * create a resource for async data fetching
+ * @template T
+ * @param {(signal: AbortSignal) => Promise<T>} fetcher - Async function to fetch data
+ * @param {(() => any) | null} deps - Optional signal to trigger refetch
+ * @param {T | null} initialValue - Initial value before data loads
+ * @returns {Object} Resource object with data, loading, error states and methods
+ */
+export function loadShot(fetcher, deps = null, initialValue = null) {
+  const [data, setData] = createMoan(initialValue);
+  const [loading, setLoading] = createMoan(false);
+  const [error, setError] = createMoan(null);
+  let controller = null;
+  const refetch = async () => {
+    if (controller) controller.abort();
+    controller = new AbortController();
+    const signal = controller.signal;
+    batch(() => {
+      setLoading(true);
+      setError(null);
+    });
+    try {
+      const result = await fetcher(signal);
+      batch(() => {
+        if (!signal.aborted) setData(result);
+      });
+    } catch (err) {
+      batch(() => {
+        if (!signal.aborted) setError(err);
+      });
+    } finally {
+      batch(() => {
+        if (!signal.aborted) setLoading(false);
+      });
+    }
+  };
+  if (deps) {
+    onClimax(() => {
+      const _ = deps();
+      refetch();
+    });
+  } else queueMicrotask(refetch);
+  const dispose = () => controller?.abort();
+  return {
+    data,
+    loading,
+    error,
+    refetch,
+    dispose,
+    idle: () => !loading() && data() === initialValue,
+    success: () => !loading() && !error(),
+    hasError: () => !!error(),
+  };
+}
+
+/**
+ * batch multiple updates together
+ * @param {Function} fn - Function to run in batch
+ */
+export function batch(fn) {
+  if (batchDepth++ === 0) pending = new Set();
+  const prev = schedule;
+  schedule = (e) => pending.add(e);
+  try {
+    fn(schedule);
+  } finally {
+    schedule = prev;
+    if (--batchDepth === 0) {
+      const effects = pending;
+      pending = null;
+      for (const e of effects) e();
+    }
+  }
+}
+
+// external scheduling
+batch.schedule = (fn) => {
+  if (batchDepth > 0) pending.add(fn);
+  else fn();
+};
+
+/**
+ * run function without tracking dependencies
+ * @template T
+ * @param {() => T} fn - Function to run without tracking
+ * @returns {T} Result of the function
+ */
+export const untrack = (fn) => {
+  const prev = currentEffect;
+  currentEffect = null;
+  try {
+    return fn();
+  } finally {
+    currentEffect = prev;
+  }
+};
+
+/**
+ * get current location (pathname, search, hash)
+ * returns a reactive signal that updates on navigation
+ * @returns {Object} Location object with location signal, active function, and dispose method
+ */
+let locationInstance = null;
+export function useLocation() {
+  if (typeof window === 'undefined') {
+    return {
+      location: () => ({ pathname: '/', search: '', hash: '' }),
+      active: () => false,
+      dispose: () => {},
+    };
+  }
+
+  // return singleton instance if already created
+  if (locationInstance) {
+    locationInstance.refCount++;
+    return {
+      location: locationInstance.location,
+      active: locationInstance.active,
+      dispose: () => {
+        if (--locationInstance.refCount === 0) {
+          locationInstance.dispose();
+          locationInstance = null;
+        }
+      },
+    };
+  }
+
+  // patch history methods once
+  if (!window.__locationPatched) {
+    ['pushState', 'replaceState'].forEach((method) => {
+      const orig = history[method];
+      history[method] = function (...args) {
+        const result = orig.apply(this, args);
+        window.dispatchEvent(new Event(method.toLowerCase()));
+        return result;
+      };
+    });
+    window.__locationPatched = true;
+  }
+
+  const getLoc = () => ({
+    pathname: window.location.pathname,
+    search: window.location.search,
+    hash: window.location.hash,
+  });
+  const [location, setLocation] = createMoan(getLoc());
+  const update = () => batch(() => setLocation(getLoc()));
+  const events = ['popstate', 'pushstate', 'replacestate'];
+  events.forEach((e) => window.addEventListener(e, update));
+
+  const active = (path) => location().pathname === path;
+  const dispose = () => events.forEach((e) => window.removeEventListener(e, update));
+
+  locationInstance = {
+    location,
+    active,
+    dispose,
+    refCount: 1,
+  };
+
+  return {
+    location,
+    active,
+    dispose: () => {
+      if (--locationInstance.refCount === 0) {
+        locationInstance.dispose();
+        locationInstance = null;
+      }
+    },
+  };
+}

package/src/app/shared/router.js

@@ -0,0 +1,153 @@
+/**
+ * cumstack Router
+ * simple manual routing with params and navigation
+ */
+
+import { createMoan } from './reactivity.js';
+
+/**
+ * parse route pattern to regex with params
+ * @param {string} pattern - Route pattern like "/user/:id"
+ * @returns {{ regex: RegExp, params: string[] }}
+ */
+function parseRoute(pattern) {
+  const params = [];
+  const regexPattern = pattern.replace(/\*/g, '.*').replace(/:(\w+)/g, (_, param) => {
+    params.push(param);
+    return '([^/]+)';
+  });
+  return {
+    regex: new RegExp(`^${regexPattern}$`),
+    params,
+  };
+}
+
+/**
+ * match a path against a pattern
+ * @param {string} path - Current path
+ * @param {string} pattern - Route pattern
+ * @returns {{ matched: boolean, params: Record<string, string> }}
+ */
+export function matchRoute(path, pattern) {
+  const { regex, params: paramNames } = parseRoute(pattern);
+  const match = path.match(regex);
+  if (!match) return { matched: false, params: {} };
+  const params = {};
+  paramNames.forEach((name, index) => (params[name] = match[index + 1]));
+  return { matched: true, params };
+}
+
+/**
+ * create a router instance
+ */
+export function createRouter() {
+  const routes = new Map();
+  const [currentPath, setCurrentPath] = createMoan(typeof window !== 'undefined' ? window.location.pathname : '/');
+  const [currentParams, setCurrentParams] = createMoan({});
+
+  /**
+   * register a route
+   * @param {string} pattern - Route pattern
+   * @param {Function} handler - Route handler
+   */
+  function register(pattern, handler) {
+    routes.set(pattern, handler);
+  }
+
+  /**
+   * navigate to a path
+   * @param {string} path - Target path
+   * @param {Object} options - Navigation options
+   */
+  function navigate(path, options = {}) {
+    if (typeof window === 'undefined') return;
+    const { replace = false, state = null } = options;
+    if (replace) window.history.replaceState(state, '', path);
+    else window.history.pushState(state, '', path);
+    setCurrentPath(path);
+    matchCurrentRoute();
+  }
+
+  /**
+   * match current route and extract params
+   */
+  function matchCurrentRoute() {
+    const path = currentPath();
+    for (const [pattern, handler] of routes) {
+      const { matched, params } = matchRoute(path, pattern);
+      if (matched) {
+        setCurrentParams(params);
+        return { handler, params };
+      }
+    }
+    return null;
+  }
+
+  /**
+   * handle browser navigation events
+   */
+  function handlePopState() {
+    setCurrentPath(window.location.pathname);
+    matchCurrentRoute();
+  }
+
+  /**
+   * initialize router
+   */
+  function init() {
+    if (typeof window !== 'undefined') {
+      window.addEventListener('popstate', handlePopState);
+      matchCurrentRoute();
+    }
+  }
+
+  return {
+    register,
+    navigate,
+    init,
+    currentPath,
+    currentParams,
+    matchRoute: matchCurrentRoute,
+  };
+}
+
+/**
+ * create a link component helper
+ * @param {string} href - Twink href
+ * @param {Object} options - Twink options
+ */
+export function createTwink(href, options = {}) {
+  return {
+    href,
+    onClick: (e) => {
+      if (options.onClick) options.onClick(e);
+      if (!e.defaultPrevented && !e.metaKey && !e.ctrlKey && !e.shiftKey && e.button === 0) {
+        e.preventDefault();
+        options.navigate?.(href);
+      }
+    },
+  };
+}
+
+/**
+ * parse query string
+ * @param {string} search - Query string
+ * @returns {Record<string, string>}
+ */
+export function parseQuery(search) {
+  const params = new URLSearchParams(search);
+  const result = {};
+  for (const [key, value] of params) result[key] = value;
+  return result;
+}
+
+/**
+ * build query string
+ * @param {Record<string, string>} params - Query params
+ * @returns {string}
+ */
+export function buildQuery(params) {
+  const searchParams = new URLSearchParams(params);
+  const query = searchParams.toString();
+  return query ? `?${query}` : '';
+}