@naeil/ui 0.8.0 → 0.10.0

package/dist/naeil-locale/chunk-D37JHNUN.js

@@ -0,0 +1,56 @@
+import {
+  assertLocale
+} from "./chunk-QWHIELL2.js";
+import {
+  __spreadValues
+} from "./chunk-N3ETBM74.js";
+
+// src/naeil-locale/messages.ts
+var sharedLoaders = {
+  en: () => import("./en-ZC66VDHP.js"),
+  ko: () => import("./ko-CY6663RZ.js"),
+  ja: () => import("./ja-DKIEQUG7.js")
+};
+function unwrap(value) {
+  return "default" in value && typeof value.default === "object" ? value.default : value;
+}
+async function loadSharedMessages(locale) {
+  return unwrap(await sharedLoaders[assertLocale(locale)]());
+}
+function validateNamespace(namespace) {
+  if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(namespace) || ["naeil", "constructor", "prototype"].includes(namespace)) throw new Error("Application message namespace conflicts with the shared namespace");
+}
+function mergeLocaleMessages(shared, application, namespace) {
+  validateNamespace(namespace);
+  if (Object.keys(application).length !== 1 || !Object.hasOwn(application, namespace) || !application[namespace] || typeof application[namespace] !== "object") throw new Error(`Messages must contain only the ${namespace} namespace`);
+  if (Object.hasOwn(shared, namespace)) throw new Error(`Duplicate message namespace: ${namespace}`);
+  return __spreadValues(__spreadValues({}, shared), application);
+}
+function createLocaleMessageLoader(options) {
+  validateNamespace(options.namespace);
+  return async function loadMessages(locale) {
+    assertLocale(locale);
+    const [shared, application] = await Promise.all([loadSharedMessages(locale), options.messages[locale]().then(unwrap)]);
+    return mergeLocaleMessages(shared, application, options.namespace);
+  };
+}
+function recoverMissingMessages(selected, english, onMissing, prefix = "") {
+  const result = __spreadValues({}, selected);
+  for (const [key, value] of Object.entries(english)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (!Object.hasOwn(result, key) || typeof value === "string" && (typeof result[key] !== "string" || !result[key])) {
+      onMissing(path);
+      result[key] = value;
+    } else if (typeof value === "object") {
+      result[key] = recoverMissingMessages(typeof result[key] === "object" ? result[key] : {}, value, onMissing, path);
+    }
+  }
+  return result;
+}
+
+export {
+  loadSharedMessages,
+  mergeLocaleMessages,
+  createLocaleMessageLoader,
+  recoverMissingMessages
+};

package/dist/naeil-locale/chunk-N3ETBM74.js

@@ -0,0 +1,24 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+export {
+  __spreadValues,
+  __spreadProps
+};

package/dist/naeil-locale/chunk-QWHIELL2.js

@@ -0,0 +1,161 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-N3ETBM74.js";
+
+// src/naeil-locale/routing.ts
+var naeilLocales = ["en", "ko", "ja"];
+var defaultLocale = "en";
+var naeilRouting = {
+  locales: naeilLocales,
+  defaultLocale,
+  localePrefix: "as-needed",
+  localeDetection: false,
+  localeCookie: false,
+  alternateLinks: false
+};
+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 = {
+  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 = {
+  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;
+}
+function localeHref(service, unlocalizedRoute, locale) {
+  return getLocaleService(service).origin + localePath(service, unlocalizedRoute, locale);
+}
+function sameLogicalRoute(service, left, right) {
+  const a = resolveLocaleUrl(service, left), b = resolveLocaleUrl(service, right);
+  if (a.kind !== "ui" || b.kind !== "ui") return false;
+  return a.logicalPath === b.logicalPath && a.canonicalPath.slice(prefixPath(a.logicalPath, a.locale).length) === b.canonicalPath.slice(prefixPath(b.logicalPath, b.locale).length);
+}
+
+export {
+  naeilLocales,
+  defaultLocale,
+  naeilRouting,
+  isNaeilLocale,
+  assertLocale,
+  defineLocaleService,
+  naeilServices,
+  getLocaleService,
+  resolveLocaleUrl,
+  localePath,
+  localeHref,
+  sameLogicalRoute
+};

package/dist/naeil-locale/chunk-YQ5OJWBF.js

@@ -0,0 +1,53 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/components/naeil-messages-context.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var NaeilMessages = createContext(null);
+function NaeilMessagesProvider({ locale, messages, children }) {
+  return /* @__PURE__ */ jsx(NaeilMessages.Provider, { value: { locale, messages }, children });
+}
+function useNaeilMessages(locale) {
+  const value = useContext(NaeilMessages);
+  if (!value || value.locale !== locale) throw new Error("Naeil chrome requires messages for its current locale");
+  return value.messages;
+}
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __objRest,
+  NaeilMessagesProvider,
+  useNaeilMessages
+};

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

@@ -0,0 +1,70 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+/** Opt-in owned-service routing. The legacy public i18n/routing entry is unchanged. */
+declare const naeilLocales: readonly ["en", "ko", "ja"];
+type NaeilLocale = (typeof naeilLocales)[number];
+type NaeilServiceId = "main" | "jev" | "estimate";
+interface NaeilRoute {
+    path: string;
+    protected?: boolean;
+}
+interface NaeilLocaleService {
+    id: NaeilServiceId;
+    origin: string;
+    routes: readonly (string | NaeilRoute)[];
+    protocolPrefixes?: readonly string[];
+    /** Explicitly audited UI routes within an otherwise protected namespace. */
+    uiProtocolExceptions?: readonly string[];
+}
+type LocaleServiceInput = NaeilLocaleService | NaeilServiceId;
+
+interface LocaleIntent {
+    token: number;
+    locale: NaeilLocale;
+    href: string;
+    startedAt: number;
+}
+
+interface LocaleMessages {
+    [key: string]: string | LocaleMessages;
+}
+
+type LocaleTransitionError = "timeout" | "navigation-failed" | "unsupported-route";
+interface LocaleChangeOptions {
+    /** A locale-neutral registered route, e.g. a translated blog listing fallback. */
+    route?: string;
+    /** Alternatively supply a fully built same-service canonical destination. */
+    href?: string;
+}
+interface LocaleController {
+    pending: boolean;
+    intent: LocaleIntent | undefined;
+    error: LocaleTransitionError | undefined;
+    changeLocale: (locale: NaeilLocale, options?: LocaleChangeOptions) => boolean;
+    retry: () => boolean;
+    cancel: () => void;
+}
+interface NaeilLocaleControllerProps {
+    service: LocaleServiceInput;
+    children: ReactNode;
+    /** Activate only after the receiver/auth rollout receipts are complete. */
+    preferenceWritesEnabled?: boolean;
+    transitionTimeoutMs?: number;
+}
+/** Lives in app/layout above [locale] and above remounting presentation. */
+declare function NaeilLocaleController({ service, children, preferenceWritesEnabled, transitionTimeoutMs }: NaeilLocaleControllerProps): react_jsx_runtime.JSX.Element;
+declare function useLocaleController(): LocaleController;
+interface NaeilLocaleProviderProps {
+    locale: NaeilLocale;
+    messages: LocaleMessages;
+    children: ReactNode;
+    timeZone?: string;
+    now?: Date;
+}
+/** Mounted in app/[locale]/layout with messages for only the requested service. */
+declare function NaeilLocaleProvider({ locale: input, messages, children, timeZone, now }: NaeilLocaleProviderProps): react_jsx_runtime.JSX.Element;
+/** Keep active through locale navigation, including failed-RSC document fallback. */
+declare function useLocaleBeforeUnload(unsafeToLeave: boolean | (() => boolean)): void;
+
+export { type LocaleChangeOptions, type LocaleController, type LocaleTransitionError, NaeilLocaleController, type NaeilLocaleControllerProps, NaeilLocaleProvider, type NaeilLocaleProviderProps, useLocaleBeforeUnload, useLocaleController };