@turnipxenon/pineapple 4.5.0-alpha.2 → 4.5.0-alpha.4

package/dist/paraglide/.prettierignore

@@ -0,0 +1,3 @@
+# ignore everything because the directory is auto-generated by inlang paraglide-js
+# for more info visit https://inlang.com/m/gerre34r/paraglide-js
+*

package/dist/paraglide/messages/_index.d.ts

@@ -0,0 +1,2 @@
+export * from "./example_message.js";
+export * from "./settings.js";

package/dist/paraglide/messages/_index.js

@@ -0,0 +1,3 @@
+// eslint-disable
+export * from './example_message.js'
+export * from './settings.js'

package/dist/paraglide/messages/example_message.d.ts

@@ -0,0 +1,5 @@
+export function example_message(inputs: {
+    username: NonNullable<unknown>;
+}, options?: {
+    locale?: "en" | "fr" | "tl";
+}): string;

package/dist/paraglide/messages/example_message.js

@@ -0,0 +1,39 @@
+// eslint-disable
+import { getLocale, trackMessageCall, experimentalMiddlewareLocaleSplitting, isServer } from '../runtime.js';
+
+const en_example_message = /** @type {(inputs: { username: NonNullable<unknown> }) => string} */ (i) => {
+	return `Hello world ${i.username}`
+};
+
+const fr_example_message = /** @type {(inputs: { username: NonNullable<unknown> }) => string} */ (i) => {
+	return `Bonjour ${i.username}`
+};
+
+const tl_example_message = /** @type {(inputs: { username: NonNullable<unknown> }) => string} */ (i) => {
+	return `Kamusta ${i.username}`
+};
+
+/**
+* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
+*
+* - Changing this function will be over-written by the next build.
+*
+* - If you want to change the translations, you can either edit the source files e.g. `en.json`, or
+* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
+* 
+* @param {{ username: NonNullable<unknown> }} inputs
+* @param {{ locale?: "en" | "fr" | "tl" }} options
+* @returns {string}
+*/
+/* @__NO_SIDE_EFFECTS__ */
+export const example_message = (inputs, options = {}) => {
+	if (experimentalMiddlewareLocaleSplitting && isServer === false) {
+		return /** @type {any} */ (globalThis).__paraglide_ssr.example_message(inputs) 
+	}
+	const locale = options.locale ?? getLocale()
+	trackMessageCall("example_message", locale)
+	if (locale === "en") return en_example_message(inputs)
+	if (locale === "fr") return fr_example_message(inputs)
+	if (locale === "tl") return tl_example_message(inputs)
+	return "example_message"
+};

package/dist/paraglide/messages/settings.d.ts

@@ -0,0 +1,3 @@
+export function settings(inputs?: {}, options?: {
+    locale?: "en" | "fr" | "tl";
+}): string;

package/dist/paraglide/messages/settings.js

@@ -0,0 +1,38 @@
+// eslint-disable
+import { getLocale, trackMessageCall, experimentalMiddlewareLocaleSplitting, isServer } from '../runtime.js';
+
+const en_settings = /** @type {(inputs: {}) => string} */ () => {
+	return `Settings`
+};
+
+const fr_settings = /** @type {(inputs: {}) => string} */ () => {
+	return `Paramètres`
+};
+
+/** @type {(inputs: {}) => string} */
+const tl_settings = en_settings;
+
+/**
+* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
+*
+* - Changing this function will be over-written by the next build.
+*
+* - If you want to change the translations, you can either edit the source files e.g. `en.json`, or
+* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
+* 
+* @param {{}} inputs
+* @param {{ locale?: "en" | "fr" | "tl" }} options
+* @returns {string}
+*/
+/* @__NO_SIDE_EFFECTS__ */
+export const settings = (inputs = {}, options = {}) => {
+	if (experimentalMiddlewareLocaleSplitting && isServer === false) {
+		return /** @type {any} */ (globalThis).__paraglide_ssr.settings(inputs) 
+	}
+	const locale = options.locale ?? getLocale()
+	trackMessageCall("settings", locale)
+	if (locale === "en") return en_settings(inputs)
+	if (locale === "fr") return fr_settings(inputs)
+	if (locale === "tl") return tl_settings(inputs)
+	return "settings"
+};

package/dist/paraglide/messages.d.ts

@@ -0,0 +1,2 @@
+export * from "./messages/_index.js";
+export * as m from "./messages/_index.js";

package/dist/paraglide/messages.js

@@ -0,0 +1,4 @@
+// eslint-disable
+export * from './messages/_index.js'
+// enabling auto-import by exposing all messages as m
+export * as m from './messages/_index.js'

package/dist/paraglide/registry.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @param {import("./runtime.js").Locale} locale
+ * @param {unknown} input
+ * @param {Intl.PluralRulesOptions} [options]
+ * @returns {string}
+ */
+export function plural(locale: import("./runtime.js").Locale, input: unknown, options?: Intl.PluralRulesOptions): string;
+/**
+ * @param {import("./runtime.js").Locale} locale
+ * @param {unknown} input
+ * @param {Intl.NumberFormatOptions} [options]
+ * @returns {string}
+ */
+export function number(locale: import("./runtime.js").Locale, input: unknown, options?: Intl.NumberFormatOptions): string;
+/**
+ * @param {import("./runtime.js").Locale} locale
+ * @param {unknown} input
+ * @param {Intl.DateTimeFormatOptions} [options]
+ * @returns {string}
+ */
+export function datetime(locale: import("./runtime.js").Locale, input: unknown, options?: Intl.DateTimeFormatOptions): string;

package/dist/paraglide/registry.js

@@ -0,0 +1,31 @@
+// eslint-disable
+
+/**
+ * @param {import("./runtime.js").Locale} locale
+ * @param {unknown} input
+ * @param {Intl.PluralRulesOptions} [options]
+ * @returns {string}
+ */
+export function plural(locale, input, options) { 
+	return new Intl.PluralRules(locale, options).select(Number(input))
+};
+
+/**
+ * @param {import("./runtime.js").Locale} locale
+ * @param {unknown} input
+ * @param {Intl.NumberFormatOptions} [options]
+ * @returns {string}
+ */
+export function number(locale, input, options) {
+	return new Intl.NumberFormat(locale, options).format(Number(input))
+};
+
+/**
+ * @param {import("./runtime.js").Locale} locale
+ * @param {unknown} input
+ * @param {Intl.DateTimeFormatOptions} [options]
+ * @returns {string}
+ */
+export function datetime(locale, input, options) {
+	return new Intl.DateTimeFormat(locale, options).format(new Date(/** @type {string} */ (input)))
+};

package/dist/paraglide/runtime.d.ts

@@ -0,0 +1,400 @@
+/**
+ * Sets the server side async local storage.
+ *
+ * The function is needed because the `runtime.js` file
+ * must define the `serverAsyncLocalStorage` variable to
+ * avoid a circular import between `runtime.js` and
+ * `server.js` files.
+ *
+ * @param {ParaglideAsyncLocalStorage | undefined} value
+ */
+export function overwriteServerAsyncLocalStorage(value: ParaglideAsyncLocalStorage | undefined): void;
+/**
+ * Check if something is an available locale.
+ *
+ * @example
+ *   if (isLocale(params.locale)) {
+ *     setLocale(params.locale);
+ *   } else {
+ *     setLocale('en');
+ *   }
+ *
+ * @param {any} locale
+ * @returns {locale is Locale}
+ */
+export function isLocale(locale: any): locale is Locale;
+/**
+ * Asserts that the input is a locale.
+ *
+ * @param {any} input - The input to check.
+ * @returns {Locale} The input if it is a locale.
+ * @throws {Error} If the input is not a locale.
+ */
+export function assertIsLocale(input: any): Locale;
+/**
+ * Extracts a cookie from the document.
+ *
+ * Will return undefined if the docuement is not available or if the cookie is not set.
+ * The `document` object is not available in server-side rendering, so this function should not be called in that context.
+ *
+ * @returns {string | undefined}
+ */
+export function extractLocaleFromCookie(): string | undefined;
+/**
+ * Extracts the locale from a given URL using native URLPattern.
+ *
+ * @param {URL|string} url - The full URL from which to extract the locale.
+ * @returns {Locale|undefined} The extracted locale, or undefined if no locale is found.
+ */
+export function extractLocaleFromUrl(url: URL | string): Locale | undefined;
+/**
+ * Lower-level URL localization function, primarily used in server contexts.
+ *
+ * This function is designed for server-side usage where you need precise control
+ * over URL localization, such as in middleware or request handlers. It works with
+ * URL objects and always returns absolute URLs.
+ *
+ * For client-side UI components, use `localizeHref()` instead, which provides
+ * a more convenient API with relative paths and automatic locale detection.
+ *
+ * @example
+ * ```typescript
+ * // Server middleware example
+ * app.use((req, res, next) => {
+ *   const url = new URL(req.url, `${req.protocol}://${req.headers.host}`);
+ *   const localized = localizeUrl(url, { locale: "de" });
+ *
+ *   if (localized.href !== url.href) {
+ *     return res.redirect(localized.href);
+ *   }
+ *   next();
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with URL patterns
+ * const url = new URL("https://example.com/about");
+ * localizeUrl(url, { locale: "de" });
+ * // => URL("https://example.com/de/about")
+ *
+ * // Using with domain-based localization
+ * const url = new URL("https://example.com/store");
+ * localizeUrl(url, { locale: "de" });
+ * // => URL("https://de.example.com/store")
+ * ```
+ *
+ * @param {string | URL} url - The URL to localize. If string, must be absolute.
+ * @param {Object} [options] - Options for localization
+ * @param {string} [options.locale] - Target locale. If not provided, uses getLocale()
+ * @returns {URL} The localized URL, always absolute
+ */
+export function localizeUrl(url: string | URL, options?: {
+    locale?: string | undefined;
+}): URL;
+/**
+ * Low-level URL de-localization function, primarily used in server contexts.
+ *
+ * This function is designed for server-side usage where you need precise control
+ * over URL de-localization, such as in middleware or request handlers. It works with
+ * URL objects and always returns absolute URLs.
+ *
+ * For client-side UI components, use `deLocalizeHref()` instead, which provides
+ * a more convenient API with relative paths.
+ *
+ * @example
+ * ```typescript
+ * // Server middleware example
+ * app.use((req, res, next) => {
+ *   const url = new URL(req.url, `${req.protocol}://${req.headers.host}`);
+ *   const baseUrl = deLocalizeUrl(url);
+ *
+ *   // Store the base URL for later use
+ *   req.baseUrl = baseUrl;
+ *   next();
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with URL patterns
+ * const url = new URL("https://example.com/de/about");
+ * deLocalizeUrl(url); // => URL("https://example.com/about")
+ *
+ * // Using with domain-based localization
+ * const url = new URL("https://de.example.com/store");
+ * deLocalizeUrl(url); // => URL("https://example.com/store")
+ * ```
+ *
+ * @param {string | URL} url - The URL to de-localize. If string, must be absolute.
+ * @returns {URL} The de-localized URL, always absolute
+ */
+export function deLocalizeUrl(url: string | URL): URL;
+export function aggregateGroups(match: any): Record<string, string | null | undefined>;
+/**
+ * High-level URL localization function optimized for client-side UI usage.
+ *
+ * This is a convenience wrapper around `localizeUrl()` that provides features
+ * needed in UI:
+ *
+ * - Accepts relative paths (e.g., "/about")
+ * - Returns relative paths when possible
+ * - Automatically detects current locale if not specified
+ * - Handles string input/output instead of URL objects
+ *
+ * @example
+ * ```typescript
+ * // In a React/Vue/Svelte component
+ * const NavLink = ({ href }) => {
+ *   // Automatically uses current locale, keeps path relative
+ *   return <a href={localizeHref(href)}>...</a>;
+ * };
+ *
+ * // Examples:
+ * localizeHref("/about")
+ * // => "/de/about" (if current locale is "de")
+ * localizeHref("/store", { locale: "fr" })
+ * // => "/fr/store" (explicit locale)
+ *
+ * // Cross-origin links remain absolute
+ * localizeHref("https://other-site.com/about")
+ * // => "https://other-site.com/de/about"
+ * ```
+ *
+ * For server-side URL localization (e.g., in middleware), use `localizeUrl()`
+ * which provides more precise control over URL handling.
+ *
+ * @param {string} href - The href to localize (can be relative or absolute)
+ * @param {Object} [options] - Options for localization
+ * @param {string} [options.locale] - Target locale. If not provided, uses `getLocale()`
+ * @returns {string} The localized href, relative if input was relative
+ */
+export function localizeHref(href: string, options?: {
+    locale?: string | undefined;
+}): string;
+/**
+ * High-level URL de-localization function optimized for client-side UI usage.
+ *
+ * This is a convenience wrapper around `deLocalizeUrl()` that provides features
+ * needed in the UI:
+ *
+ * - Accepts relative paths (e.g., "/de/about")
+ * - Returns relative paths when possible
+ * - Handles string input/output instead of URL objects
+ *
+ * @example
+ * ```typescript
+ * // In a React/Vue/Svelte component
+ * const LocaleSwitcher = ({ href }) => {
+ *   // Remove locale prefix before switching
+ *   const baseHref = deLocalizeHref(href);
+ *   return locales.map(locale =>
+ *     <a href={localizeHref(baseHref, { locale })}>
+ *       Switch to {locale}
+ *     </a>
+ *   );
+ * };
+ *
+ * // Examples:
+ * deLocalizeHref("/de/about")  // => "/about"
+ * deLocalizeHref("/fr/store")  // => "/store"
+ *
+ * // Cross-origin links remain absolute
+ * deLocalizeHref("https://example.com/de/about")
+ * // => "https://example.com/about"
+ * ```
+ *
+ * For server-side URL de-localization (e.g., in middleware), use `deLocalizeUrl()`
+ * which provides more precise control over URL handling.
+ *
+ * @param {string} href - The href to de-localize (can be relative or absolute)
+ * @returns {string} The de-localized href, relative if input was relative
+ * @see deLocalizeUrl - For low-level URL de-localization in server contexts
+ */
+export function deLocalizeHref(href: string): string;
+/**
+ * @param {string} safeModuleId
+ * @param {Locale} locale
+ */
+export function trackMessageCall(safeModuleId: string, locale: Locale): void;
+/**
+ * Generates a list of localized URLs for all provided URLs.
+ *
+ * This is useful for SSG (Static Site Generation) and sitemap generation.
+ * NextJS and other frameworks use this function for SSG.
+ *
+ * @example
+ * ```typescript
+ * const urls = generateStaticLocalizedUrls([
+ *   "https://example.com/about",
+ *   "https://example.com/blog",
+ * ]);
+ * urls[0].href // => "https://example.com/about"
+ * urls[1].href // => "https://example.com/blog"
+ * urls[2].href // => "https://example.com/de/about"
+ * urls[3].href // => "https://example.com/de/blog"
+ * ...
+ * ```
+ *
+ * @param {(string | URL)[]} urls - List of URLs to generate localized versions for. Can be absolute URLs or paths.
+ * @returns {URL[]} List of localized URLs as URL objects
+ */
+export function generateStaticLocalizedUrls(urls: (string | URL)[]): URL[];
+/**
+ * The project's base locale.
+ *
+ * @example
+ *   if (locale === baseLocale) {
+ *     // do something
+ *   }
+ */
+export const baseLocale: "en";
+/**
+ * The project's locales that have been specified in the settings.
+ *
+ * @example
+ *   if (locales.includes(userSelectedLocale) === false) {
+ *     throw new Error('Locale is not available');
+ *   }
+ */
+export const locales: readonly ["en", "fr", "tl"];
+/** @type {string} */
+export const cookieName: string;
+/** @type {string} */
+export const localStorageKey: string;
+/**
+ * @type {Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage">}
+ */
+export const strategy: Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage">;
+/**
+ * The used URL patterns.
+ *
+ * @type {Array<{ pattern: string, localized: Array<[Locale, string]> }> }
+ */
+export const urlPatterns: Array<{
+    pattern: string;
+    localized: Array<[Locale, string]>;
+}>;
+/**
+ * @typedef {{
+ * 		getStore(): {
+ *   		locale?: Locale,
+ * 			origin?: string,
+ * 			messageCalls?: Set<string>
+ *   	} | undefined,
+ * 		run: (store: { locale?: Locale, origin?: string, messageCalls?: Set<string>},
+ *    cb: any) => any
+ * }} ParaglideAsyncLocalStorage
+ */
+/**
+ * Server side async local storage that is set by `serverMiddleware()`.
+ *
+ * The variable is used to retrieve the locale and origin in a server-side
+ * rendering context without effecting other requests.
+ *
+ * @type {ParaglideAsyncLocalStorage | undefined}
+ */
+export let serverAsyncLocalStorage: ParaglideAsyncLocalStorage | undefined;
+export const disableAsyncLocalStorage: false;
+export const experimentalMiddlewareLocaleSplitting: false;
+export const isServer: boolean;
+/**
+ * Get the current locale.
+ *
+ * @example
+ *   if (getLocale() === 'de') {
+ *     console.log('Germany 🇩🇪');
+ *   } else if (getLocale() === 'nl') {
+ *     console.log('Netherlands 🇳🇱');
+ *   }
+ *
+ * @type {() => Locale}
+ */
+export let getLocale: () => Locale;
+/**
+ * Overwrite the \`getLocale()\` function.
+ *
+ * Use this function to overwrite how the locale is resolved. For example,
+ * you can resolve the locale from the browser's preferred language,
+ * a cookie, env variable, or a user's preference.
+ *
+ * @example
+ *   overwriteGetLocale(() => {
+ *     // resolve the locale from a cookie. fallback to the base locale.
+ *     return Cookies.get('locale') ?? baseLocale
+ *   }
+ *
+ * @type {(fn: () => Locale) => void}
+ */
+export const overwriteGetLocale: (fn: () => Locale) => void;
+/**
+ * Set the locale.
+ *
+ * Set locale reloads the site by default on the client. Reloading
+ * can be disabled by passing \`reload: false\` as an option. If
+ * reloading is disbaled, you need to ensure that the UI is updated
+ * to reflect the new locale.
+ *
+ * @example
+ *   setLocale('en');
+ *
+ * @example
+ *   setLocale('en', { reload: false });
+ *
+ * @type {(newLocale: Locale, options?: { reload?: boolean }) => void}
+ */
+export let setLocale: (newLocale: Locale, options?: {
+    reload?: boolean;
+}) => void;
+export function overwriteSetLocale(fn: (newLocale: Locale) => void): void;
+/**
+ * The origin of the current URL.
+ *
+ * Defaults to "http://y.com" in non-browser environments. If this
+ * behavior is not desired, the implementation can be overwritten
+ * by `overwriteGetUrlOrigin()`.
+ *
+ * @type {() => string}
+ */
+export let getUrlOrigin: () => string;
+/**
+ * Overwrite the getUrlOrigin function.
+ *
+ * Use this function in server environments to
+ * define how the URL origin is resolved.
+ *
+ * @type {(fn: () => string) => void}
+ */
+export let overwriteGetUrlOrigin: (fn: () => string) => void;
+/**
+ * Extracts a locale from a request.
+ *
+ * Use the function on the server to extract the locale
+ * from a request.
+ *
+ * The function goes through the strategies in the order
+ * they are defined. If a strategy returns an invalid locale,
+ * it will fall back to the next strategy.
+ *
+ * @example
+ *   const locale = extractLocaleFromRequest(request);
+ *
+ * @type {(request: Request) => Locale}
+ */
+export const extractLocaleFromRequest: (request: Request) => Locale;
+export type ParaglideAsyncLocalStorage = {
+    getStore(): {
+        locale?: Locale;
+        origin?: string;
+        messageCalls?: Set<string>;
+    } | undefined;
+    run: (store: {
+        locale?: Locale;
+        origin?: string;
+        messageCalls?: Set<string>;
+    }, cb: any) => any;
+};
+/**
+ * A locale that is available in the project.
+ */
+export type Locale = (typeof locales)[number];