@naeil/ui 0.9.0 → 0.11.0

package/dist/naeil-locale/client.js

@@ -0,0 +1,388 @@
+"use client";
+"use client";
+import {
+  NaeilMessagesProvider,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-YQ5OJWBF.js";
+
+// src/naeil-locale/client.tsx
+import { createContext, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { usePathname, useRouter } from "next/navigation";
+import { NextIntlClientProvider } from "next-intl";
+
+// src/naeil-locale/routing.ts
+var naeilLocales = ["en", "ko", "ja"];
+function isNaeilLocale(value) {
+  return typeof value === "string" && naeilLocales.includes(value);
+}
+function assertLocale(value) {
+  if (!isNaeilLocale(value)) throw new Error("Unsupported naeil locale");
+  return value;
+}
+var origins = {
+  abstorm: "https://abstorm.naeil.dev",
+  main: "https://naeil.dev",
+  jev: "https://jev.naeil.dev",
+  estimate: "https://abestimate.naeil.dev"
+};
+var protocolPrefixes = ["/api", "/auth", "/_next", "/_vercel", "/.well-known", "/health", "/invite", "/return", "/webhook", "/images", "/fonts"];
+var protocolFiles = ["/favicon.ico", "/icon.svg", "/apple-icon.png", "/robots.txt", "/sitemap.xml"];
+function defineLocaleService(service) {
+  var _a, _b, _c, _d;
+  if (origins[service.id] !== service.origin) throw new Error("Service origin must match the exact owned origin");
+  const paths = service.routes.map((route) => typeof route === "string" ? route : route.path);
+  if (!paths.length || new Set(paths).size !== paths.length) throw new Error("Route inventory is empty or duplicated");
+  for (const path of paths) {
+    if (!/^\/(?:[A-Za-z0-9._~-]+|\[[A-Za-z][A-Za-z0-9_]*\])(?:\/(?:[A-Za-z0-9._~-]+|\[[A-Za-z][A-Za-z0-9_]*\]))*$/.test(path) && path !== "/") throw new Error(`Invalid registered route: ${path}`);
+    if (/^\/(?:en|ko|ja)(?:\/|$)/.test(path) || isProtocolPath(path, service) && !((_a = service.uiProtocolExceptions) == null ? void 0 : _a.includes(path)) || path.split("/").some((segment) => segment === "." || segment === "..")) throw new Error(`Locale/protocol path cannot be a UI route: ${path}`);
+  }
+  for (const exception of (_b = service.uiProtocolExceptions) != null ? _b : []) if (exception.includes("[") || !paths.includes(exception)) throw new Error("Protocol UI exceptions must be exact registered routes");
+  return Object.freeze(__spreadProps(__spreadValues({}, service), { routes: Object.freeze(service.routes.map((route) => typeof route === "string" ? route : Object.freeze(__spreadValues({}, route)))), protocolPrefixes: Object.freeze([...(_c = service.protocolPrefixes) != null ? _c : []]), uiProtocolExceptions: Object.freeze([...(_d = service.uiProtocolExceptions) != null ? _d : []]) }));
+}
+var main = defineLocaleService({ id: "main", origin: origins.main, routes: ["/", "/projects", "/design", "/blog", "/blog/[slug]", "/login", { path: "/login/change-password", protected: true }] });
+var naeilServices = {
+  abstorm: defineLocaleService({
+    id: "abstorm",
+    origin: origins.abstorm,
+    routes: ["/", "/new", "/runs/[id]", "/runs/[id]/report", "/experts"].map((path) => ({ path, protected: true }))
+  }),
+  main,
+  site: main,
+  jev: defineLocaleService({ id: "jev", origin: origins.jev, routes: [{ path: "/", protected: true }, "/login"] }),
+  estimate: defineLocaleService({ id: "estimate", origin: origins.estimate, uiProtocolExceptions: ["/auth/complete"], routes: ["/", "/estimates", "/estimates/[id]", "/compare", "/settings", "/calendar", "/calendar-preview", "/calendar-preview/estimates", "/calendar-preview/estimates/[id]"].map((path) => ({ path, protected: true })).concat([{ path: "/login", protected: false }, { path: "/access-denied", protected: false }, { path: "/auth/complete", protected: false }]) })
+};
+function getLocaleService(service) {
+  return typeof service === "string" ? naeilServices[service] : service;
+}
+function isProtocolPath(path, service) {
+  var _a;
+  return [...protocolPrefixes, ...(_a = service.protocolPrefixes) != null ? _a : []].some((prefix) => path === prefix || path.startsWith(prefix + "/")) || protocolFiles.includes(path);
+}
+function matchRoute(service, pathname) {
+  const segments = pathname.split("/");
+  for (const route of service.routes) {
+    const record = typeof route === "string" ? { path: route } : route;
+    const expected = record.path.split("/");
+    if (expected.length === segments.length && expected.every((part, index) => part === segments[index] || /^\[[A-Za-z][A-Za-z0-9_]*\]$/.test(part) && !!segments[index])) return record;
+  }
+}
+function invalid(reason, status = 404, locale) {
+  return __spreadValues({ kind: "invalid", status, reason }, locale ? { locale } : {});
+}
+function splitInput(input, origin) {
+  if (!input || /[\u0000-\u0020\u007f\\]/.test(input)) return;
+  let path = input;
+  if (!path.startsWith("/")) {
+    if (!path.startsWith(origin + "/") && path !== origin) return;
+    path = path.slice(origin.length) || "/";
+  }
+  if (path.startsWith("//")) return;
+  const hashAt = path.indexOf("#");
+  const hash = hashAt < 0 ? "" : path.slice(hashAt);
+  const withoutHash = hashAt < 0 ? path : path.slice(0, hashAt);
+  const queryAt = withoutHash.indexOf("?");
+  return { pathname: queryAt < 0 ? withoutHash : withoutHash.slice(0, queryAt), search: queryAt < 0 ? "" : withoutHash.slice(queryAt), hash };
+}
+function safePath(path) {
+  if (!path.startsWith("/") || path.includes("//")) return false;
+  return path.split("/").every((segment) => {
+    try {
+      const decoded = decodeURIComponent(segment);
+      return !/[\u0000-\u001f\u007f/\\%?#]/.test(decoded) && decoded !== "." && decoded !== ".." && (!/^(?:en|ko|ja|api|auth|_next|invite|return|webhook)$/.test(decoded) || decoded === segment);
+    } catch (e) {
+      return false;
+    }
+  });
+}
+function stripLegacyLang(search) {
+  const retained = search.slice(1).split("&").filter((part) => {
+    try {
+      return decodeURIComponent(part.split("=")[0].replace(/\+/g, " ")) !== "lang";
+    } catch (e) {
+      return true;
+    }
+  });
+  return retained.length && retained.join("&") ? "?" + retained.join("&") : "";
+}
+function prefixPath(path, locale) {
+  return locale === "en" ? path : `/${locale}${path === "/" ? "" : path}`;
+}
+function resolveLocaleUrl(inputService, input) {
+  var _a, _b;
+  const service = getLocaleService(inputService);
+  const parts = splitInput(input, service.origin);
+  if (!parts || !safePath(parts.pathname)) return invalid("Malformed or encoded path");
+  const rawPathname = parts.pathname;
+  const pathname = rawPathname !== "/" && rawPathname.endsWith("/") ? rawPathname.slice(0, -1) : rawPathname;
+  if (isProtocolPath(pathname, service) && !((_a = service.uiProtocolExceptions) == null ? void 0 : _a.includes(pathname))) return { kind: "protocol", pathname };
+  const segments = pathname.split("/");
+  const explicit = isNaeilLocale(segments[1]);
+  const pathLocale = explicit ? segments[1] : void 0;
+  const logicalPath = explicit ? "/" + segments.slice(2).join("/") : pathname;
+  if (/^\/(?:en|ko|ja)(?:\/|$)/.test(logicalPath) || isProtocolPath(logicalPath, service) && !((_b = service.uiProtocolExceptions) == null ? void 0 : _b.includes(logicalPath))) return invalid("Nested locale or localized protocol path", 404, pathLocale);
+  const route = matchRoute(service, logicalPath);
+  if (!route) return invalid("Unregistered UI route", 404, pathLocale);
+  const legacy = service.id !== "main";
+  const languages = new URLSearchParams(parts.search).getAll("lang");
+  if (legacy && languages.length && (languages.length !== 1 || !isNaeilLocale(languages[0]))) return invalid("Invalid legacy language", 400, pathLocale);
+  const locale = pathLocale != null ? pathLocale : legacy && languages.length ? languages[0] : "en";
+  const search = legacy ? stripLegacyLang(parts.search) : parts.search;
+  const canonicalPath = prefixPath(logicalPath, locale) + search + parts.hash;
+  const originalPath = rawPathname + parts.search + parts.hash;
+  return { kind: "ui", locale, logicalPath, route, canonicalPath, originalPath, alias: canonicalPath !== originalPath };
+}
+function localePath(inputService, unlocalizedRoute, locale) {
+  assertLocale(locale);
+  const service = getLocaleService(inputService);
+  const parts = splitInput(unlocalizedRoute, service.origin);
+  if (!parts || /^\/(?:en|ko|ja)(?:\/|$)/.test(parts.pathname)) throw new Error("localePath requires an unlocalized route");
+  const result = resolveLocaleUrl(service, parts.pathname);
+  if (result.kind !== "ui") throw new Error("Unregistered UI destination");
+  return prefixPath(result.logicalPath, locale) + (service.id === "main" ? parts.search : stripLegacyLang(parts.search)) + parts.hash;
+}
+
+// src/naeil-locale/intent.ts
+function createLocaleIntentGate(service) {
+  let serial = 0;
+  let pending;
+  return {
+    begin(href, locale, now = Date.now()) {
+      if (pending) return;
+      const resolved = resolveLocaleUrl(service, href);
+      if (resolved.kind !== "ui" || resolved.alias || resolved.locale !== locale) throw new Error("Invalid locale intent target");
+      pending = { token: ++serial, locale, href: resolved.canonicalPath, startedAt: now };
+      return pending;
+    },
+    current() {
+      return pending;
+    },
+    cancel(token) {
+      if (token === void 0 || (pending == null ? void 0 : pending.token) === token) pending = void 0;
+    },
+    arrive(token, href, locale) {
+      const resolved = resolveLocaleUrl(service, href);
+      if (!pending || pending.token !== token || pending.locale !== locale || resolved.kind !== "ui" || resolved.alias || resolved.canonicalPath !== pending.href) return;
+      const committed = pending;
+      pending = void 0;
+      return committed;
+    }
+  };
+}
+
+// src/naeil-locale/preference.ts
+var localePreferenceCookie = "naeil_locale_v1";
+var developmentPreferenceCookie = "naeil_locale_dev_v1";
+function preferenceCookieWrites(locale, location) {
+  assertLocale(locale);
+  const production = location.hostname === "naeil.dev" || location.hostname.endsWith(".naeil.dev");
+  if (production) {
+    if (location.protocol !== "https:") return [];
+    return [
+      `${localePreferenceCookie}=; Path=/; Max-Age=0; Secure; SameSite=Lax`,
+      `${localePreferenceCookie}=${locale}; Domain=naeil.dev; Path=/; Max-Age=31536000; Secure; SameSite=Lax`
+    ];
+  }
+  return [`${developmentPreferenceCookie}=${locale}; Path=/; Max-Age=31536000; SameSite=Lax${location.protocol === "https:" ? "; Secure" : ""}`];
+}
+function writeLocalePreference(locale, environment, enabled = false) {
+  if (!enabled) return false;
+  try {
+    const writes = preferenceCookieWrites(locale, environment.location);
+    for (const cookie of writes) environment.writeCookie(cookie);
+    return writes.length > 0;
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/naeil-locale/client.tsx
+import { jsx } from "react/jsx-runtime";
+function captureFocus() {
+  const active = document.activeElement;
+  if (!(active instanceof HTMLElement)) return;
+  if (active.closest("[data-naeil-locale-menu]")) return { attribute: "data-naeil-focus-id", value: "locale-control" };
+  const attribute = ["data-naeil-focus-id", "id", "name"].find((key) => active.hasAttribute(key));
+  if (!attribute) return;
+  const snapshot = { attribute, value: active.getAttribute(attribute) };
+  if (active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement) {
+    snapshot.start = active.selectionStart;
+    snapshot.end = active.selectionEnd;
+    snapshot.direction = active.selectionDirection;
+  }
+  return snapshot;
+}
+function restoreFocus(snapshot) {
+  var _a;
+  if (!snapshot) return;
+  const element = Array.from(document.querySelectorAll(`[${snapshot.attribute}]`)).find((node) => node.getAttribute(snapshot.attribute) === snapshot.value && node.getClientRects().length > 0);
+  if (!element) return;
+  element.focus({ preventScroll: true });
+  if ((element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) && snapshot.start !== void 0 && snapshot.start !== null && snapshot.end !== void 0 && snapshot.end !== null) {
+    try {
+      element.setSelectionRange(snapshot.start, snapshot.end, (_a = snapshot.direction) != null ? _a : void 0);
+    } catch (e) {
+    }
+  }
+}
+function browserHref() {
+  return window.location.pathname + window.location.search + window.location.hash;
+}
+var LocaleControllerContext = createContext(null);
+function NaeilLocaleController({ service, children, preferenceWritesEnabled = false, transitionTimeoutMs = 2e4 }) {
+  const router = useRouter();
+  const pathname = usePathname();
+  const [gate] = useState(() => createLocaleIntentGate(service));
+  const [intent, setIntent] = useState();
+  const [error, setError] = useState();
+  const lastRequest = useRef(void 0);
+  const focus = useRef(void 0);
+  const timer = useRef(void 0);
+  const guards = useRef(/* @__PURE__ */ new Set());
+  const clearTimer = useCallback(() => {
+    if (timer.current !== void 0) clearTimeout(timer.current);
+    timer.current = void 0;
+  }, []);
+  const cancel = useCallback(() => {
+    gate.cancel();
+    clearTimer();
+    setIntent(void 0);
+    setError(void 0);
+    focus.current = void 0;
+  }, [gate, clearTimer]);
+  const fail = useCallback((token, reason) => {
+    var _a;
+    if (((_a = gate.current()) == null ? void 0 : _a.token) !== token) return;
+    gate.cancel(token);
+    clearTimer();
+    setIntent(void 0);
+    setError(reason);
+  }, [gate, clearTimer]);
+  const changeLocale = useCallback((language, options) => {
+    var _a;
+    const locale = assertLocale(language);
+    if (gate.current()) return false;
+    const current = resolveLocaleUrl(service, browserHref());
+    if (current.kind !== "ui") {
+      setError("unsupported-route");
+      return false;
+    }
+    if (current.locale === locale && !(options == null ? void 0 : options.route) && !(options == null ? void 0 : options.href)) return false;
+    const suffix = current.canonicalPath.slice(localePath(service, current.logicalPath, current.locale).length);
+    let href;
+    try {
+      if (options == null ? void 0 : options.href) {
+        if (options.route) throw new Error("Use either route or href");
+        const supplied = resolveLocaleUrl(service, options.href);
+        if (supplied.kind !== "ui" || supplied.locale !== locale || supplied.alias) throw new Error("Invalid locale destination");
+        href = supplied.canonicalPath;
+      } else href = localePath(service, (_a = options == null ? void 0 : options.route) != null ? _a : current.logicalPath + suffix, locale);
+    } catch (e) {
+      setError("unsupported-route");
+      return false;
+    }
+    const request = gate.begin(href, locale);
+    if (!request) return false;
+    lastRequest.current = { locale, options };
+    focus.current = captureFocus();
+    setIntent(request);
+    setError(void 0);
+    timer.current = setTimeout(() => fail(request.token, "timeout"), transitionTimeoutMs);
+    try {
+      router.replace(href, { scroll: false });
+      return true;
+    } catch (e) {
+      fail(request.token, "navigation-failed");
+      return false;
+    }
+  }, [service, gate, router, fail, transitionTimeoutMs]);
+  const retry = useCallback(() => lastRequest.current ? changeLocale(lastRequest.current.locale, lastRequest.current.options) : false, [changeLocale]);
+  const arrive = useCallback((token, locale, committedPathname) => {
+    if (token === void 0 || committedPathname !== window.location.pathname) return;
+    const committed = gate.arrive(token, browserHref(), locale);
+    if (!committed) return;
+    clearTimer();
+    setIntent(void 0);
+    setError(void 0);
+    writeLocalePreference(locale, { location: window.location, writeCookie: (cookie) => {
+      document.cookie = cookie;
+    } }, preferenceWritesEnabled);
+    const savedFocus = focus.current;
+    focus.current = void 0;
+    requestAnimationFrame(() => restoreFocus(savedFocus));
+  }, [gate, clearTimer, preferenceWritesEnabled]);
+  const registerDepartureGuard = useCallback((guard) => {
+    guards.current.add(guard);
+    return () => {
+      guards.current.delete(guard);
+    };
+  }, []);
+  useEffect(() => {
+    const onPopState = () => cancel();
+    const beforeUnload = (event) => {
+      if ([...guards.current].some((guard) => {
+        try {
+          return guard();
+        } catch (e) {
+          return true;
+        }
+      })) {
+        event.preventDefault();
+        event.returnValue = "";
+      }
+    };
+    window.addEventListener("popstate", onPopState);
+    window.addEventListener("beforeunload", beforeUnload);
+    return () => {
+      window.removeEventListener("popstate", onPopState);
+      window.removeEventListener("beforeunload", beforeUnload);
+      gate.cancel();
+      clearTimer();
+    };
+  }, [cancel, gate, clearTimer]);
+  useEffect(() => {
+    const pending = gate.current();
+    if (!pending) return;
+    const target = pending.href.split(/[?#]/, 1)[0];
+    const current = resolveLocaleUrl(service, pathname != null ? pathname : "/");
+    const destination = resolveLocaleUrl(service, target);
+    if (current.kind !== "ui" || destination.kind !== "ui" || current.logicalPath !== destination.logicalPath) cancel();
+  }, [pathname, service, gate, cancel]);
+  const context = useMemo(() => ({ pending: !!intent, intent, error, changeLocale, retry, cancel, service, arrive, registerDepartureGuard }), [intent, error, changeLocale, retry, cancel, service, arrive, registerDepartureGuard]);
+  return /* @__PURE__ */ jsx(LocaleControllerContext.Provider, { value: context, children });
+}
+function useLocaleController() {
+  const controller = useContext(LocaleControllerContext);
+  if (!controller) throw new Error("NaeilLocaleController is required above the locale route");
+  return controller;
+}
+function NaeilLocaleProvider({ locale: input, messages, children, timeZone = "UTC", now }) {
+  var _a;
+  const locale = assertLocale(input);
+  const controller = useContext(LocaleControllerContext);
+  const pathname = usePathname();
+  const token = (_a = controller == null ? void 0 : controller.intent) == null ? void 0 : _a.token;
+  const arrive = controller == null ? void 0 : controller.arrive;
+  useEffect(() => {
+    document.documentElement.lang = locale;
+    if (pathname) arrive == null ? void 0 : arrive(token, locale, pathname);
+  }, [locale, pathname, token, arrive]);
+  if (!messages.naeil || typeof messages.naeil !== "object") throw new Error("NaeilLocaleProvider requires the shared naeil namespace");
+  return /* @__PURE__ */ jsx(NextIntlClientProvider, { locale, messages, timeZone, now, children: /* @__PURE__ */ jsx(NaeilMessagesProvider, { locale, messages: messages.naeil, children }) });
+}
+function useLocaleBeforeUnload(unsafeToLeave) {
+  const controller = useContext(LocaleControllerContext);
+  if (!controller) throw new Error("NaeilLocaleController is required for departure protection");
+  const current = useRef(unsafeToLeave);
+  useLayoutEffect(() => {
+    current.current = unsafeToLeave;
+  }, [unsafeToLeave]);
+  const register = controller.registerDepartureGuard;
+  useEffect(() => register(() => typeof current.current === "function" ? current.current() : current.current), [register]);
+}
+export {
+  NaeilLocaleController,
+  NaeilLocaleProvider,
+  useLocaleBeforeUnload,
+  useLocaleController
+};

package/dist/naeil-locale/en-ZC66VDHP.js

@@ -0,0 +1,86 @@
+import "./chunk-N3ETBM74.js";
+
+// src/naeil-locale/messages/en.json
+var naeil = {
+  header: {
+    nav: {
+      home: "Home",
+      projects: "Projects",
+      blog: "Blog",
+      navigation: "Main navigation",
+      menu: "Menu",
+      closeMenu: "Close menu"
+    },
+    theme: {
+      switchToLight: "Switch to light theme",
+      switchToDark: "Switch to dark theme"
+    },
+    locale: {
+      switchLabel: "Language"
+    },
+    projects: {
+      cc: {
+        name: "Content Collector",
+        description: "Automated content collection from RSS, YouTube, Reddit + AI summarization"
+      },
+      pkm: {
+        name: "PKM",
+        description: "Personal knowledge management \u2014 document parsing, embeddings, semantic search"
+      },
+      naeilUi: {
+        name: "naeil-ui",
+        description: "Minimal design system \u2014 OKLCH tokens, Tailwind v4, shadcn"
+      },
+      sa: {
+        name: "Sustainability Analyzer",
+        description: "AI-powered ESG report analysis \u2014 PDF parsing, qualitative assessment, comparison tables"
+      },
+      babyAgent: {
+        name: "Baby Agent",
+        description: "Parenting AI agent \u2014 LINE-based Q&A, records, reminders"
+      },
+      status: {
+        active: "Active",
+        coming: "Coming Soon"
+      }
+    }
+  },
+  account: {
+    menu: "Account menu",
+    account: "Account",
+    login: "Log in",
+    logout: "Log out",
+    busy: "Logging out\u2026"
+  },
+  footer: {
+    navigation: "Navigation",
+    projects: "Projects",
+    blog: "Blog",
+    social: "Social",
+    description: "Tomorrow starts here."
+  },
+  locale: {
+    names: {
+      en: "English",
+      ko: "\uD55C\uAD6D\uC5B4",
+      ja: "\u65E5\u672C\u8A9E"
+    },
+    pending: "Changing language\u2026",
+    failed: "The language could not be changed. Your work is still here.",
+    retry: "Try again",
+    errors: {
+      badRequest: "This address is not valid.",
+      notFound: "Page not found.",
+      unauthenticated: "Sign in to continue.",
+      forbidden: "You do not have access to this page.",
+      unavailable: "The service is temporarily unavailable. Please try again."
+    }
+  }
+};
+var en_default = {
+  naeil
+};
+export {
+  en_default as default,
+  naeil
+};

package/dist/naeil-locale/index.d.ts

@@ -0,0 +1,40 @@
+import { N as NaeilLocale, a as LocaleServiceInput } from './messages-BuQvB-u2.js';
+export { b as LocaleMessageLoaders, L as LocaleMessages, c as LocaleUrlResolution, d as NaeilLocaleService, e as NaeilRoute, f as NaeilServiceId, R as ResolvedLocaleRoute, S as SharedMessages, g as assertLocale, h as defaultLocale, i as defineLocaleService, j as getLocaleService, k as isNaeilLocale, l as localeHref, m as localePath, n as naeilLocales, o as naeilRouting, p as naeilServices, r as resolveLocaleUrl, s as sameLogicalRoute } from './messages-BuQvB-u2.js';
+
+declare const localePreferenceCookie: string;
+declare const developmentPreferenceCookie: string;
+declare function readLocalePreference(cookie: string, development?: boolean): NaeilLocale | undefined;
+declare function preferenceCookieWrites(locale: NaeilLocale, location: {
+    hostname: string;
+    protocol: string;
+}): string[];
+declare function writeLocalePreference(locale: NaeilLocale, environment: {
+    location: {
+        hostname: string;
+        protocol: string;
+    };
+    writeCookie: (cookie: string) => void;
+}, enabled?: boolean): boolean;
+declare function browserLocaleHint(languages: readonly string[]): NaeilLocale | undefined;
+/** Legacy reads are hint-only and expire against the recorded activation date. */
+declare function legacyLocaleHint(options: {
+    activatedAt: number | undefined;
+    now: number;
+    values: readonly (string | null | undefined)[];
+}): NaeilLocale | undefined;
+
+interface LocaleIntent {
+    token: number;
+    locale: NaeilLocale;
+    href: string;
+    startedAt: number;
+}
+/** Pure arrival gate. Router invocation/prefetch alone is never a commit. */
+declare function createLocaleIntentGate(service: LocaleServiceInput): {
+    begin(href: string, locale: NaeilLocale, now?: number): LocaleIntent | undefined;
+    current(): LocaleIntent | undefined;
+    cancel(token?: number): void;
+    arrive(token: number, href: string, locale: NaeilLocale): LocaleIntent | undefined;
+};
+
+export { type LocaleIntent, LocaleServiceInput, NaeilLocale, browserLocaleHint, createLocaleIntentGate, developmentPreferenceCookie, legacyLocaleHint, localePreferenceCookie, preferenceCookieWrites, readLocalePreference, writeLocalePreference };

package/dist/naeil-locale/index.js

@@ -0,0 +1,111 @@
+import {
+  assertLocale,
+  defaultLocale,
+  defineLocaleService,
+  getLocaleService,
+  isNaeilLocale,
+  localeHref,
+  localePath,
+  naeilLocales,
+  naeilRouting,
+  naeilServices,
+  resolveLocaleUrl,
+  sameLogicalRoute
+} from "./chunk-U65OQHZY.js";
+import "./chunk-N3ETBM74.js";
+
+// src/naeil-locale/preference.ts
+var localePreferenceCookie = "naeil_locale_v1";
+var developmentPreferenceCookie = "naeil_locale_dev_v1";
+function readLocalePreference(cookie, development = false) {
+  const name = development ? developmentPreferenceCookie : localePreferenceCookie;
+  const matches = cookie.split(";").map((item) => item.trim()).filter((item) => item.split("=", 1)[0] === name);
+  if (matches.length !== 1) return;
+  const value = matches[0].slice(name.length + 1);
+  return isNaeilLocale(value) ? value : void 0;
+}
+function preferenceCookieWrites(locale, location) {
+  assertLocale(locale);
+  const production = location.hostname === "naeil.dev" || location.hostname.endsWith(".naeil.dev");
+  if (production) {
+    if (location.protocol !== "https:") return [];
+    return [
+      `${localePreferenceCookie}=; Path=/; Max-Age=0; Secure; SameSite=Lax`,
+      `${localePreferenceCookie}=${locale}; Domain=naeil.dev; Path=/; Max-Age=31536000; Secure; SameSite=Lax`
+    ];
+  }
+  return [`${developmentPreferenceCookie}=${locale}; Path=/; Max-Age=31536000; SameSite=Lax${location.protocol === "https:" ? "; Secure" : ""}`];
+}
+function writeLocalePreference(locale, environment, enabled = false) {
+  if (!enabled) return false;
+  try {
+    const writes = preferenceCookieWrites(locale, environment.location);
+    for (const cookie of writes) environment.writeCookie(cookie);
+    return writes.length > 0;
+  } catch (e) {
+    return false;
+  }
+}
+function browserLocaleHint(languages) {
+  for (const language of languages) {
+    try {
+      const base = new Intl.Locale(language).language;
+      if (isNaeilLocale(base)) return base;
+    } catch (e) {
+    }
+  }
+}
+function legacyLocaleHint(options) {
+  if (options.activatedAt === void 0 || options.now >= options.activatedAt + 90 * 864e5 || options.now < options.activatedAt) return;
+  return options.values.find(isNaeilLocale);
+}
+
+// src/naeil-locale/intent.ts
+function createLocaleIntentGate(service) {
+  let serial = 0;
+  let pending;
+  return {
+    begin(href, locale, now = Date.now()) {
+      if (pending) return;
+      const resolved = resolveLocaleUrl(service, href);
+      if (resolved.kind !== "ui" || resolved.alias || resolved.locale !== locale) throw new Error("Invalid locale intent target");
+      pending = { token: ++serial, locale, href: resolved.canonicalPath, startedAt: now };
+      return pending;
+    },
+    current() {
+      return pending;
+    },
+    cancel(token) {
+      if (token === void 0 || (pending == null ? void 0 : pending.token) === token) pending = void 0;
+    },
+    arrive(token, href, locale) {
+      const resolved = resolveLocaleUrl(service, href);
+      if (!pending || pending.token !== token || pending.locale !== locale || resolved.kind !== "ui" || resolved.alias || resolved.canonicalPath !== pending.href) return;
+      const committed = pending;
+      pending = void 0;
+      return committed;
+    }
+  };
+}
+export {
+  assertLocale,
+  browserLocaleHint,
+  createLocaleIntentGate,
+  defaultLocale,
+  defineLocaleService,
+  developmentPreferenceCookie,
+  getLocaleService,
+  isNaeilLocale,
+  legacyLocaleHint,
+  localeHref,
+  localePath,
+  localePreferenceCookie,
+  naeilLocales,
+  naeilRouting,
+  naeilServices,
+  preferenceCookieWrites,
+  readLocalePreference,
+  resolveLocaleUrl,
+  sameLogicalRoute,
+  writeLocalePreference
+};