ranuts 0.4.1-alpha.2 → 0.5.1

package/dist/src/utils/localePath.js

@@ -0,0 +1,48 @@
+var W = (s) => {
+  let r = s.length;
+  for (; r > 0 && s[r - 1] === "/"; ) r--;
+  return s.slice(0, r);
+}, g = (s) => {
+  const r = W(s.trim());
+  return r ? r.startsWith("/") ? r : `/${r}` : "";
+}, h = (s) => {
+  const r = s.search(/[?#]/);
+  return r === -1 ? [s, ""] : [s.slice(0, r), s.slice(r)];
+}, P = (s) => {
+  const r = s.locales.length > 0 ? s.locales : [{ code: "en" }], i = g(s.base ?? ""), c = s.defaultLocale ?? (r.find((t) => !t.prefix) ?? r[0]).code, u = r.filter((t) => t.prefix).sort((t, e) => e.prefix.length - t.prefix.length), x = (t) => r.find((e) => e.code === t) ?? { code: c }, a = (t) => {
+    const e = t || "/";
+    return i ? e === i ? "/" : e.startsWith(`${i}/`) ? e.slice(i.length) : e.startsWith("/") ? e : `/${e}` : e.startsWith("/") ? e : `/${e}`;
+  }, f = (t) => {
+    const e = t.split("/").filter(Boolean)[0], n = e ? u.find((l) => l.prefix === e) : void 0;
+    if (!n) return {
+      code: c,
+      rest: t
+    };
+    const o = t.slice(n.prefix.length + 1) || "/";
+    return {
+      code: n.code,
+      rest: o.startsWith("/") ? o : `/${o}`
+    };
+  }, $ = (t) => f(a(h(t)[0])).code, m = (t) => {
+    const [e, n] = h(t);
+    return `${i}${f(a(e)).rest}${n}`;
+  }, d = (t, e = c) => {
+    const [n, o] = h(t), { rest: l } = f(a(n)), { prefix: p } = x(e), L = p ? `/${p}${l}` : l;
+    return `${i}${L}${o}` || "/";
+  };
+  return {
+    base: i,
+    defaultLocale: c,
+    localeFromPath: $,
+    stripLocale: m,
+    href: d,
+    hrefForLocale: (t, e) => d(t, e),
+    alternates: (t) => r.map((e) => ({
+      code: e.code,
+      href: d(t, e.code)
+    }))
+  };
+};
+export {
+  P as createLocalePath
+};

package/dist/src/utils/memoize.d.ts

@@ -19,12 +19,6 @@ export type Func = (...args: any[]) => unknown;
  * ```
  */
 export declare const once: <T extends Func>(fn: T | unknown) => ((...args: Parameters<T>) => ReturnType<T>);
-/**
- * @description: Former name of `once`. The name is misleading — it does not cache per
- * argument, it simply runs once.
- * @deprecated Use [`once`](#once) instead; for the async case use [`singleFlight`](#singleflight).
- */
-export declare const memoize: typeof once;
 export interface SingleFlight<T> {
     (): Promise<T>;
     /** Drop the cached result so the next call runs again (connection lost, logout, forced refresh) */
@@ -35,7 +29,7 @@ export interface SingleFlight<T> {
 /**
  * @description: The async flavour of "run once": concurrent callers share one in-flight
  * promise, later callers reuse the resolved result, and **a rejection clears the cache**
- * so it can be retried (this is where it differs from `memoize` — caching a rejected
+ * so it can be retried (this is where it differs from `once` — caching a rejected
  * promise turns one flaky network blip into a permanent failure).
  *
  * The typical use is a resource that is initialised once but awaited by everyone: opening

package/dist/src/utils/memoize.js

@@ -0,0 +1,16 @@
+var u = (n) => {
+  let e = !1, t, r = n;
+  return (...l) => (e || (t = typeof r == "function" ? r(...l) : r, e = !0, r = void 0), t);
+}, c = (n) => {
+  let e = null;
+  const t = () => (e ??= n().catch((r) => {
+    throw e = null, r;
+  }), e);
+  return t.reset = () => {
+    e = null;
+  }, Object.defineProperty(t, "started", { get: () => e !== null }), t;
+};
+export {
+  u as once,
+  c as singleFlight
+};