@yozora-tech/qfluent 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (C) 2026 Yozora Tech LTD
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,39 @@
+# qfluent
+
+ProjectFluent.org translations support for Qwik framework v2.
+
+## Synopsis
+
+```tsx
+import { T, useT } from "@yozora-tech/qfluent";
+
+<T s="hello-world" />
+
+const t_search_empty = useT("search-the-web");
+<input type="search" placeholder={t_search_empty.value} />
+```
+
+## Links
+
+- Document: https://qfluent.yozora.tech/
+  - Source: [site/src/routes/en/index.mdx](./site/src/routes/en/index.mdx)
+- npm: https://www.npmjs.com/package/@yozora-tech/qfluent
+- jsr: https://jsr.io/@yozora-tech/qfluent
+
+## AI (LLM) Usage
+
+### By Human
+
+- `src/qfluent/*`
+- `site/src/routes/*`
+
+### By LLM
+
+- `src/tests/*`
+- `site/src/*.css`
+
+## Legal
+
+Copyright © 2026 Yozora Tech LTD. [MIT/Expat](./LICENSE) License.
+
+Feel free to use the idea.

package/lib/assets/DVjQdr_6-bundle-graph.json

@@ -0,0 +1 @@
+["../index.qwik.cjs",4,5,"../qfluent/context.qwik.cjs","../qfluent/tools.qwik.cjs","../qfluent/translate.qwik.cjs",3]

package/lib/assets/l4W0yvKV-bundle-graph.json

@@ -0,0 +1 @@
+["../index.qwik.mjs",4,5,"../qfluent/context.qwik.mjs","../qfluent/tools.qwik.mjs","../qfluent/translate.qwik.mjs",3]

package/lib/i18n.d.ts

@@ -0,0 +1,2 @@
+import type { QwikFluentResource } from "./index";
+export declare const i18nResources: QwikFluentResource[];

package/lib/index.d.ts

@@ -0,0 +1 @@
+export * from "./qfluent/mod";

package/lib/index.qwik.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const context = require("./qfluent/context.qwik.cjs");
+const translate = require("./qfluent/translate.qwik.cjs");
+const tools = require("./qfluent/tools.qwik.cjs");
+exports.FluentProvider = context.FluentProvider;
+exports.useFluentErrors = context.useFluentErrors;
+exports.useFluentLocales = context.useFluentLocales;
+exports.useFluentResources = context.useFluentResources;
+exports.T = translate.T;
+exports.useLocalizedTitle = translate.useLocalizedTitle;
+exports.useT = translate.useT;
+exports.parseAcceptLanguage = tools.parseAcceptLanguage;

package/lib/index.qwik.mjs

@@ -0,0 +1,13 @@
+import { FluentProvider, useFluentErrors, useFluentLocales, useFluentResources } from "./qfluent/context.qwik.mjs";
+import { T, useLocalizedTitle, useT } from "./qfluent/translate.qwik.mjs";
+import { parseAcceptLanguage } from "./qfluent/tools.qwik.mjs";
+export {
+  FluentProvider,
+  T,
+  parseAcceptLanguage,
+  useFluentErrors,
+  useFluentLocales,
+  useFluentResources,
+  useLocalizedTitle,
+  useT
+};

package/lib/q-manifest.json

@@ -0,0 +1,69 @@
+{
+	"version": "1",
+	"manifestHash": "m6gwie",
+	"options": {
+		"target": "lib",
+		"buildMode": "development",
+		"entryStrategy": {
+			"type": "inline"
+		}
+	},
+	"bundleGraphAsset": "assets/DVjQdr_6-bundle-graph.json",
+	"injections": [],
+	"mapping": {},
+	"bundles": {
+		"../index.qwik.cjs": {
+			"size": 632,
+			"total": 17193,
+			"imports": [
+				"../qfluent/context.qwik.cjs",
+				"../qfluent/tools.qwik.cjs",
+				"../qfluent/translate.qwik.cjs"
+			],
+			"origins": [
+				"src/index.ts"
+			],
+			"interactivity": 0
+		},
+		"../qfluent/context.qwik.cjs": {
+			"size": 6830,
+			"total": 6830,
+			"origins": [
+				"src/qfluent/context.tsx"
+			],
+			"interactivity": 0
+		},
+		"../qfluent/tools.qwik.cjs": {
+			"size": 505,
+			"total": 505,
+			"origins": [
+				"src/qfluent/tools.ts"
+			],
+			"interactivity": 0
+		},
+		"../qfluent/translate.qwik.cjs": {
+			"size": 2396,
+			"total": 9226,
+			"imports": [
+				"../qfluent/context.qwik.cjs"
+			],
+			"origins": [
+				"src/qfluent/translate.tsx"
+			],
+			"interactivity": 0
+		}
+	},
+	"assets": {
+		"assets/DVjQdr_6-bundle-graph.json": {
+			"name": "bundle-graph.json",
+			"size": 7
+		}
+	},
+	"symbols": {},
+	"platform": {
+		"vite": "",
+		"rollup": "4.62.2",
+		"env": "deno",
+		"os": "linux"
+	}
+}

package/lib/qfluent/context.d.ts

@@ -0,0 +1,54 @@
+import { NoSerialize, Signal } from "@qwik.dev/core";
+import type { FluentProviderProps, QwikFluentBundleMap, QwikFluentError, QwikFluentResourceMap } from "./types";
+/** @internal */
+export declare const FluentLocalesId: import("@qwik.dev/core").ContextId<Signal<string[]>>;
+/** @internal */
+export declare const FluentResourcesId: import("@qwik.dev/core").ContextId<Signal<NoSerialize<QwikFluentResourceMap>>>;
+/** @internal */
+export declare const FluentBundlesId: import("@qwik.dev/core").ContextId<Signal<NoSerialize<QwikFluentBundleMap>>>;
+/** @internal */
+export declare const FluentErrorsId: import("@qwik.dev/core").ContextId<Signal<NoSerialize<QwikFluentError[]>>>;
+/**
+ * Signal to list of preferred locales. Translations are picked from these languages, with fallbacks as needed.
+ *
+ * Normally you want to set this to `preferred_languages.concat(navigator.languages)`.
+ *
+ * ```tsx
+ * const locales = useFluentLocales();
+ * return (
+ *   <select onChange$={(event, select) => {
+ *     locales.value = [select.value].concat(navigator.languages);
+ *   }}>
+ *     <option value="ar">Arabic</option>
+ *     <option value="en">English</option>
+ *     <option value="ja">Japanese</option>
+ *     ...
+ *   </select>
+ * );
+ * ```
+ */
+export declare function useFluentLocales(): Signal<string[]>;
+/**
+ * Includes your resources and compiled FluentBundles by locales.
+ *
+ * You can make use of your custom resource properties with this.
+ */
+export declare function useFluentResources<T extends QwikFluentResourceMap>(): Signal<T | undefined>;
+/**
+ * Useful for debugging errors in resources.
+ *
+ * You can clear the errors after use.
+ */
+export declare function useFluentErrors(): Signal<QwikFluentError[]>;
+/**
+ * Use this in `src/root.tsx`.
+ *
+ * ```tsx
+ * <body>
+ *   <FluentProvider resources={...}>
+ *     <RouterOutlet />
+ *   </FluentProvider>
+ * </body>
+ * ```
+ */
+export declare const FluentProvider: import("@qwik.dev/core").Component<FluentProviderProps>;

package/lib/qfluent/context.qwik.cjs

@@ -0,0 +1,195 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@qwik.dev/core");
+const bundle = require("@fluent/bundle");
+const FluentLocalesId = core.createContextId("QwikFluentLocales");
+const FluentResourcesId = core.createContextId("QwikFluentResources");
+const FluentBundlesId = core.createContextId("QwikFluentBundles");
+const FluentErrorsId = core.createContextId("QwikFluentErrors");
+function useFluentLocales() {
+  return core.useContext(FluentLocalesId);
+}
+function useFluentResources() {
+  return core.useContext(FluentResourcesId);
+}
+function useFluentErrors() {
+  return core.useContext(FluentErrorsId);
+}
+function ataToUtf8(pathname) {
+  const label = ";base64,";
+  const a = pathname.indexOf(label);
+  if (a === -1) {
+    throw new Error("Invalid ata url pathname: " + pathname);
+  }
+  const binaryString = atob(pathname.slice(a + label.length));
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return new TextDecoder().decode(bytes);
+}
+const FluentProvider = /* @__PURE__ */ core.componentQrl(/* @__PURE__ */ core.inlinedQrl((_rawProps) => {
+  const locales = core.useSignal(_rawProps.acceptLanguage ?? [
+    "en"
+  ]);
+  const bunmap = core.useSignal({});
+  const resmap = core.useSignal({});
+  const errors = core.useSignal([]);
+  core.useContextProvider(FluentLocalesId, locales);
+  core.useContextProvider(FluentBundlesId, bunmap);
+  core.useContextProvider(FluentResourcesId, resmap);
+  core.useContextProvider(FluentErrorsId, errors);
+  const ssr = core.useSignal(true);
+  core.useOnDocument("load", /* @__PURE__ */ core.inlinedQrl(() => {
+    const locales2 = core._captures[0], ssr2 = core._captures[1];
+    if (!ssr2.value) return;
+    ssr2.value = false;
+    locales2.value = navigator.languages.concat();
+  }, "FluentProvider_component_useOnDocument_9BL0L0WgLlY", [
+    locales,
+    ssr
+  ]));
+  core.useTaskQrl(/* @__PURE__ */ core.inlinedQrl((_rawProps1) => {
+    const _rawProps2 = core._captures[0], bunmap2 = core._captures[1], errors2 = core._captures[2], locales2 = core._captures[3], resmap2 = core._captures[4], ssr2 = core._captures[5];
+    _rawProps1.track(locales2);
+    _rawProps1.track(ssr2);
+    if (!bunmap2.value) {
+      bunmap2.value = {};
+    }
+    if (!resmap2.value) {
+      resmap2.value = {};
+    }
+    if (!errors2.value) {
+      errors2.value = [];
+    }
+    const res = core.noSerialize(resmap2.value);
+    const bun = core.noSerialize(bunmap2.value);
+    const promises = [];
+    const whitelist = locales2.value;
+    let has_errors = false;
+    for (const r of _rawProps2.resources) {
+      let ok = false;
+      for (const x of r.locales) {
+        if (res[x]) {
+          break;
+        }
+        if (whitelist.includes(x)) {
+          ok = true;
+          break;
+        }
+      }
+      if (!ok) {
+        continue;
+      }
+      const b = new bundle.FluentBundle(r.locales);
+      for (const x of r.locales) {
+        res[x] = r;
+        bun[x] = b;
+      }
+      for (const url of r.resources) {
+        let promise;
+        if (core.isServer) {
+          let path = url.toString().slice(1);
+          {
+            path = new URL(path, new URL("../dist/", _rawProps2.origin));
+          }
+          if (path.protocol === "ata:") {
+            promise = new Promise((resolve, reject) => {
+              try {
+                resolve(ataToUtf8(path.pathname));
+              } catch (err) {
+                reject(err);
+              }
+            });
+          } else {
+            promise = import("node:fs/promises").then((fs) => fs.readFile(path.pathname)).then((buf) => new TextDecoder().decode(buf));
+          }
+        } else {
+          promise = fetch(url).then((resp) => resp.text());
+        }
+        promises.push(promise.then((s) => {
+          const errset = b.addResource(new bundle.FluentResource(s));
+          if (errset.length) {
+            errors2.value.push({
+              resource: r,
+              errors: errset
+            });
+            has_errors = true;
+            console.error(`[qfluent] Errors in resource ${url}:`, errset);
+          }
+        }));
+      }
+    }
+    return Promise.all(promises).then(() => {
+      bunmap2.trigger();
+      resmap2.trigger();
+      if (has_errors) {
+        errors2.trigger();
+      }
+    });
+  }, "FluentProvider_component_useTask_0r0LUJYLJnU", [
+    _rawProps,
+    bunmap,
+    errors,
+    locales,
+    resmap,
+    ssr
+  ]));
+  core.useTaskQrl(/* @__PURE__ */ core.inlinedQrl(({ track }) => {
+    const locales2 = core._captures[0], resmap2 = core._captures[1], ssr2 = core._captures[2];
+    if (track(ssr2)) return;
+    if (!track(resmap2)) return;
+    track(locales2);
+    const root = document.querySelector("html");
+    if (!root) return;
+    for (const l of locales2.value) {
+      const b = resmap2.value[l];
+      if (!b) {
+        continue;
+      }
+      root.lang = l;
+      const dir = b.dir;
+      if (dir) {
+        root.dir = dir;
+      } else {
+        root.dir = "";
+      }
+      break;
+    }
+  }, "FluentProvider_component_useTask_1_GdWGQNUVI4g", [
+    locales,
+    resmap,
+    ssr
+  ]));
+  return /* @__PURE__ */ core._jsxSorted(core.Slot, null, null, null, 3, "76_0");
+}, "FluentProvider_component_LWfKAJ3jVqM"));
+exports.FluentBundlesId = FluentBundlesId;
+exports.FluentErrorsId = FluentErrorsId;
+exports.FluentLocalesId = FluentLocalesId;
+exports.FluentProvider = FluentProvider;
+exports.FluentResourcesId = FluentResourcesId;
+exports.useFluentErrors = useFluentErrors;
+exports.useFluentLocales = useFluentLocales;
+exports.useFluentResources = useFluentResources;

package/lib/qfluent/context.qwik.mjs

@@ -0,0 +1,173 @@
+import { createContextId, useContext, componentQrl, inlinedQrl, useSignal, useContextProvider, useOnDocument, _captures, useTaskQrl, noSerialize, isServer, _jsxSorted, Slot } from "@qwik.dev/core";
+import { FluentBundle, FluentResource } from "@fluent/bundle";
+const FluentLocalesId = createContextId("QwikFluentLocales");
+const FluentResourcesId = createContextId("QwikFluentResources");
+const FluentBundlesId = createContextId("QwikFluentBundles");
+const FluentErrorsId = createContextId("QwikFluentErrors");
+function useFluentLocales() {
+  return useContext(FluentLocalesId);
+}
+function useFluentResources() {
+  return useContext(FluentResourcesId);
+}
+function useFluentErrors() {
+  return useContext(FluentErrorsId);
+}
+function ataToUtf8(pathname) {
+  const label = ";base64,";
+  const a = pathname.indexOf(label);
+  if (a === -1) {
+    throw new Error("Invalid ata url pathname: " + pathname);
+  }
+  const binaryString = atob(pathname.slice(a + label.length));
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return new TextDecoder().decode(bytes);
+}
+const FluentProvider = /* @__PURE__ */ componentQrl(/* @__PURE__ */ inlinedQrl((_rawProps) => {
+  const locales = useSignal(_rawProps.acceptLanguage ?? [
+    "en"
+  ]);
+  const bunmap = useSignal({});
+  const resmap = useSignal({});
+  const errors = useSignal([]);
+  useContextProvider(FluentLocalesId, locales);
+  useContextProvider(FluentBundlesId, bunmap);
+  useContextProvider(FluentResourcesId, resmap);
+  useContextProvider(FluentErrorsId, errors);
+  const ssr = useSignal(true);
+  useOnDocument("load", /* @__PURE__ */ inlinedQrl(() => {
+    const locales2 = _captures[0], ssr2 = _captures[1];
+    if (!ssr2.value) return;
+    ssr2.value = false;
+    locales2.value = navigator.languages.concat();
+  }, "FluentProvider_component_useOnDocument_9BL0L0WgLlY", [
+    locales,
+    ssr
+  ]));
+  useTaskQrl(/* @__PURE__ */ inlinedQrl((_rawProps1) => {
+    const _rawProps2 = _captures[0], bunmap2 = _captures[1], errors2 = _captures[2], locales2 = _captures[3], resmap2 = _captures[4], ssr2 = _captures[5];
+    _rawProps1.track(locales2);
+    _rawProps1.track(ssr2);
+    if (!bunmap2.value) {
+      bunmap2.value = {};
+    }
+    if (!resmap2.value) {
+      resmap2.value = {};
+    }
+    if (!errors2.value) {
+      errors2.value = [];
+    }
+    const res = noSerialize(resmap2.value);
+    const bun = noSerialize(bunmap2.value);
+    const promises = [];
+    const whitelist = locales2.value;
+    let has_errors = false;
+    for (const r of _rawProps2.resources) {
+      let ok = false;
+      for (const x of r.locales) {
+        if (res[x]) {
+          break;
+        }
+        if (whitelist.includes(x)) {
+          ok = true;
+          break;
+        }
+      }
+      if (!ok) {
+        continue;
+      }
+      const b = new FluentBundle(r.locales);
+      for (const x of r.locales) {
+        res[x] = r;
+        bun[x] = b;
+      }
+      for (const url of r.resources) {
+        let promise;
+        if (isServer) {
+          let path = url.toString().slice(1);
+          {
+            path = new URL(path, new URL("../dist/", _rawProps2.origin));
+          }
+          if (path.protocol === "ata:") {
+            promise = new Promise((resolve, reject) => {
+              try {
+                resolve(ataToUtf8(path.pathname));
+              } catch (err) {
+                reject(err);
+              }
+            });
+          } else {
+            promise = import("node:fs/promises").then((fs) => fs.readFile(path.pathname)).then((buf) => new TextDecoder().decode(buf));
+          }
+        } else {
+          promise = fetch(url).then((resp) => resp.text());
+        }
+        promises.push(promise.then((s) => {
+          const errset = b.addResource(new FluentResource(s));
+          if (errset.length) {
+            errors2.value.push({
+              resource: r,
+              errors: errset
+            });
+            has_errors = true;
+            console.error(`[qfluent] Errors in resource ${url}:`, errset);
+          }
+        }));
+      }
+    }
+    return Promise.all(promises).then(() => {
+      bunmap2.trigger();
+      resmap2.trigger();
+      if (has_errors) {
+        errors2.trigger();
+      }
+    });
+  }, "FluentProvider_component_useTask_0r0LUJYLJnU", [
+    _rawProps,
+    bunmap,
+    errors,
+    locales,
+    resmap,
+    ssr
+  ]));
+  useTaskQrl(/* @__PURE__ */ inlinedQrl(({ track }) => {
+    const locales2 = _captures[0], resmap2 = _captures[1], ssr2 = _captures[2];
+    if (track(ssr2)) return;
+    if (!track(resmap2)) return;
+    track(locales2);
+    const root = document.querySelector("html");
+    if (!root) return;
+    for (const l of locales2.value) {
+      const b = resmap2.value[l];
+      if (!b) {
+        continue;
+      }
+      root.lang = l;
+      const dir = b.dir;
+      if (dir) {
+        root.dir = dir;
+      } else {
+        root.dir = "";
+      }
+      break;
+    }
+  }, "FluentProvider_component_useTask_1_GdWGQNUVI4g", [
+    locales,
+    resmap,
+    ssr
+  ]));
+  return /* @__PURE__ */ _jsxSorted(Slot, null, null, null, 3, "76_0");
+}, "FluentProvider_component_LWfKAJ3jVqM"));
+export {
+  FluentBundlesId,
+  FluentErrorsId,
+  FluentLocalesId,
+  FluentProvider,
+  FluentResourcesId,
+  useFluentErrors,
+  useFluentLocales,
+  useFluentResources
+};

package/lib/qfluent/mod.d.ts

@@ -0,0 +1,4 @@
+export type { FluentProviderProps, FluentTProps, QwikFluentError, QwikFluentResource, QwikFluentResourceMap, } from "./types";
+export { FluentProvider, useFluentErrors, useFluentLocales, useFluentResources, } from "./context";
+export { T, useLocalizedTitle, useT } from "./translate";
+export { parseAcceptLanguage } from "./tools";

package/lib/qfluent/tools.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parse an `Accept-Language` header as array of locales, sorted by quality value.
+ *
+ * ```ts
+ * parseAcceptLanguage("en-US;q=0.3, ja, zh-CN;q=0.9, zh;q=0.7")
+ * // [ "ja", "zh-CN", "zh", "en-US" ]
+ * ```
+ */
+export declare function parseAcceptLanguage(header: string): string[];

package/lib/qfluent/tools.qwik.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function parseAcceptLanguage(header) {
+  return header.split(",").map((entry) => {
+    const [locale, ...params] = entry.split(";");
+    const q = params.find((p) => p.trim().startsWith("q="));
+    return {
+      locale: locale.trim(),
+      q: q ? parseFloat(q.split("=")[1]) : 1
+    };
+  }).filter((x) => x.locale).sort((a, b) => b.q - a.q).map((x) => x.locale);
+}
+exports.parseAcceptLanguage = parseAcceptLanguage;

package/lib/qfluent/tools.qwik.mjs

@@ -0,0 +1,13 @@
+function parseAcceptLanguage(header) {
+  return header.split(",").map((entry) => {
+    const [locale, ...params] = entry.split(";");
+    const q = params.find((p) => p.trim().startsWith("q="));
+    return {
+      locale: locale.trim(),
+      q: q ? parseFloat(q.split("=")[1]) : 1
+    };
+  }).filter((x) => x.locale).sort((a, b) => b.q - a.q).map((x) => x.locale);
+}
+export {
+  parseAcceptLanguage
+};

package/lib/qfluent/translate.d.ts

@@ -0,0 +1,33 @@
+import { Component, Signal } from "@qwik.dev/core";
+import type { FluentTProps } from "./types";
+/**
+ * Translate a string in TSX idiom.
+ *
+ * Pass a signal for `args`.
+ *
+ * ```tsx
+ * const x = useSignal(1);
+ * return <T s="x-apples" args={x} />;
+ * ```
+ */
+export declare const T: Component<FluentTProps>;
+/**
+ * Return a reactive signal to a translated string.
+ *
+ * Useful for non-DOM use cases (like `document.title`, see `useLocalizedTitle`).
+ *
+ * ```ts
+ * const t = useT("my-title");
+ * useTask$(({ track }) => {
+ *   track(t);
+ *   document.title = t.value;
+ * });
+ * ```
+ */
+export declare function useT<T>(s: string, args?: Signal<T>): Signal<string>;
+/**
+ * Make the document title (`<title>` element in `<head>`) translated, and follow locale changes.
+ *
+ * Note: Only effective after resumption on clients. Title generated during SSG is untouched.
+ */
+export declare function useLocalizedTitle<T>(s: string, args?: Signal<T>): void;

package/lib/qfluent/translate.qwik.cjs

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@qwik.dev/core");
+const context = require("./context.qwik.cjs");
+function wrapArgs(args) {
+  switch (typeof args) {
+    case "string":
+    case "number":
+    case "bigint":
+    case "boolean":
+      return {
+        x: args
+      };
+    case "undefined":
+      return {
+        x: "undefined"
+      };
+    case "object":
+      if (args === null) {
+        return {
+          x: "null"
+        };
+      }
+      return args;
+    default:
+      return {
+        x: String(args)
+      };
+  }
+}
+function dummyT(s, args) {
+  return s + (args ? " + " + args : "");
+}
+function useT(s, args) {
+  const locales = context.useFluentLocales();
+  const bundles = core.useContext(context.FluentBundlesId);
+  const message = core.useComputedQrl(/* @__PURE__ */ core.inlinedQrl(() => {
+    const args2 = core._captures[0], bundles2 = core._captures[1], locales2 = core._captures[2], s2 = core._captures[3];
+    const value = args2?.value;
+    const placeholder = dummyT(s2, value);
+    const wargs = wrapArgs(value);
+    if (!bundles2.value) {
+      return placeholder;
+    }
+    for (const k of locales2.value) {
+      const b = bundles2.value[k];
+      if (!b) {
+        continue;
+      }
+      const m = b.getMessage(s2);
+      if (!m || !m.value) {
+        continue;
+      }
+      return b.formatPattern(m.value, wargs);
+    }
+    return placeholder;
+  }, "useT_message_useComputed_S0G7htNeJXI", [
+    args,
+    bundles,
+    locales,
+    s
+  ]));
+  return message;
+}
+const T = /* @__PURE__ */ core.componentQrl(/* @__PURE__ */ core.inlinedQrl((_rawProps) => {
+  return useT(_rawProps.s, _rawProps.args).value;
+}, "T_component_g8a5BXhl0hY"));
+function useLocalizedTitle(s, args) {
+  const t = useT(s, args);
+  core.useOnDocument("qidle", /* @__PURE__ */ core.inlinedQrl(() => {
+    const t2 = core._captures[0];
+    if (typeof document === "undefined") return;
+    document.title = t2.value;
+  }, "useLocalizedTitle_useOnDocument_VXsb0xE3U2c", [
+    t
+  ]));
+  core.useTaskQrl(/* @__PURE__ */ core.inlinedQrl(({ track }) => {
+    const t2 = core._captures[0];
+    track(t2);
+    if (typeof document === "undefined") return;
+    document.title = t2.value;
+  }, "useLocalizedTitle_useTask_MxJmwSF2dkE", [
+    t
+  ]));
+}
+exports.T = T;
+exports.useLocalizedTitle = useLocalizedTitle;
+exports.useT = useT;

package/lib/qfluent/translate.qwik.mjs

@@ -0,0 +1,88 @@
+import { componentQrl, inlinedQrl, useOnDocument, _captures, useTaskQrl, useContext, useComputedQrl } from "@qwik.dev/core";
+import { useFluentLocales, FluentBundlesId } from "./context.qwik.mjs";
+function wrapArgs(args) {
+  switch (typeof args) {
+    case "string":
+    case "number":
+    case "bigint":
+    case "boolean":
+      return {
+        x: args
+      };
+    case "undefined":
+      return {
+        x: "undefined"
+      };
+    case "object":
+      if (args === null) {
+        return {
+          x: "null"
+        };
+      }
+      return args;
+    default:
+      return {
+        x: String(args)
+      };
+  }
+}
+function dummyT(s, args) {
+  return s + (args ? " + " + args : "");
+}
+function useT(s, args) {
+  const locales = useFluentLocales();
+  const bundles = useContext(FluentBundlesId);
+  const message = useComputedQrl(/* @__PURE__ */ inlinedQrl(() => {
+    const args2 = _captures[0], bundles2 = _captures[1], locales2 = _captures[2], s2 = _captures[3];
+    const value = args2?.value;
+    const placeholder = dummyT(s2, value);
+    const wargs = wrapArgs(value);
+    if (!bundles2.value) {
+      return placeholder;
+    }
+    for (const k of locales2.value) {
+      const b = bundles2.value[k];
+      if (!b) {
+        continue;
+      }
+      const m = b.getMessage(s2);
+      if (!m || !m.value) {
+        continue;
+      }
+      return b.formatPattern(m.value, wargs);
+    }
+    return placeholder;
+  }, "useT_message_useComputed_S0G7htNeJXI", [
+    args,
+    bundles,
+    locales,
+    s
+  ]));
+  return message;
+}
+const T = /* @__PURE__ */ componentQrl(/* @__PURE__ */ inlinedQrl((_rawProps) => {
+  return useT(_rawProps.s, _rawProps.args).value;
+}, "T_component_g8a5BXhl0hY"));
+function useLocalizedTitle(s, args) {
+  const t = useT(s, args);
+  useOnDocument("qidle", /* @__PURE__ */ inlinedQrl(() => {
+    const t2 = _captures[0];
+    if (typeof document === "undefined") return;
+    document.title = t2.value;
+  }, "useLocalizedTitle_useOnDocument_VXsb0xE3U2c", [
+    t
+  ]));
+  useTaskQrl(/* @__PURE__ */ inlinedQrl(({ track }) => {
+    const t2 = _captures[0];
+    track(t2);
+    if (typeof document === "undefined") return;
+    document.title = t2.value;
+  }, "useLocalizedTitle_useTask_MxJmwSF2dkE", [
+    t
+  ]));
+}
+export {
+  T,
+  useLocalizedTitle,
+  useT
+};

package/lib/qfluent/types.d.ts

@@ -0,0 +1,129 @@
+import type { Signal } from "@qwik.dev/core";
+import type { FluentBundle } from "@fluent/bundle";
+/**
+ * One pre-defined fluent resource entry.
+ *
+ * Import .ftl files as URL. Example:
+ *
+ * ```ts
+ * import en_ftl from "./i18n/en.ftl?url";
+ *
+ * export const i18nResources: QwikFluentResource[] = [{
+ *   name: "English",
+ *   locales: ["en", "en-US"],
+ *   resources: [en_ftl],
+ * }];
+ * ```
+ */
+export interface QwikFluentResource {
+    /**
+     * Language name.
+     *
+     * ```ts
+     * {
+     *   name: "English (US)",
+     * }
+     * ```
+     */
+    name: string;
+    /**
+     * Applicable locales to given resources.
+     * Most specific first.
+     *
+     * ```ts
+     * {
+     *   locales: ["en-US", "en"],
+     * }
+     * ```
+     */
+    locales: string[];
+    /**
+     * Resource URLs. Import them like this:
+     *
+     * ```ts
+     * import en_ftl from "./i18n/en.ftl?url";
+     *
+     * {
+     *   resources: [en_ftl],
+     * }
+     * ```
+     */
+    resources: (URL | string)[];
+    /**
+     * Text layout direction. Specify this as `"rtl"` for
+     * languages like Arabic, Hebrew, etc.
+     *
+     * ```ts
+     * {
+     *   locales: ["ar"],
+     *   dir: "rtl",
+     * }
+     * ```
+     */
+    dir?: "rtl";
+}
+export interface FluentProviderProps {
+    /** Initial locales to use. `["en"]` by default. */
+    acceptLanguage?: string[];
+    /**
+     * URL origin for development and SSR to work properly.
+     *
+     * Set this to project root directory (which has `package.json`).
+     *
+     * Typically you just need:
+     *
+     * ```tsx
+     * // src/root.tsx
+     * <FluentProvider origin={new URL("..", import.meta.url)} resources={...}>
+     * ```
+     */
+    origin: URL;
+    /**
+     * Fluent Resources.
+     *
+     * ```ts
+     * import en_ftl from "./i18n/en.ftl?url";
+     *
+     * export const i18nResources: QwikFluentResource[] = [
+     *   {
+     *     name: "English",
+     *     locales: ["en-US", "en"],
+     *     resources: [en_ftl],
+     *   },
+     * ];
+     * ```
+     */
+    resources: QwikFluentResource[];
+}
+/**
+ * Key is individual locale like `"en" "en-US"`.
+ *
+ * Only contains loaded resources.
+ *
+ * You can have custom properties in your resources.
+ * Re-use them with `useFluentResources`.
+ */
+export type QwikFluentResourceMap = {
+    [locale: string]: QwikFluentResource;
+};
+/** @internal */
+export type QwikFluentBundleMap = {
+    [locale: string]: FluentBundle;
+};
+/**
+ * Errors related to certain resource when parsing it.
+ */
+export interface QwikFluentError {
+    resource: QwikFluentResource;
+    errors: Error[];
+}
+export interface FluentTProps {
+    /** The key for translation string. */
+    s: string;
+    /**
+     * Optional argument(s) in a signal.
+     *
+     * If it's not an object, it will be wrapped as `{ x: args }`.
+     */
+    args?: Signal<unknown>;
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@yozora-tech/qfluent",
+  "version": "0.1.0",
+  "description": "ProjectFluent.org translations support for Qwik framework v2.",
+  "main": "./lib/index.qwik.mjs",
+  "qwik": "./lib/index.qwik.mjs",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.qwik.mjs",
+      "require": "./lib/index.qwik.cjs"
+    }
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "lib"
+  ],
+  "engines": {
+    "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+  },
+  "private": false,
+  "sideEffects": false,
+  "type": "module",
+  "scripts": {
+    "build": "qwik build",
+    "build.lib": "vite build --mode lib",
+    "build.types": "tsc -p tsconfig.types.json --emitDeclarationOnly --incremental false",
+    "dev": "vite --mode ssr",
+    "dev.debug": "node --inspect-brk ./node_modules/vite/bin/vite.js --mode ssr --force",
+    "fmt": "deno fmt .",
+    "fmt.check": "deno fmt --check .",
+    "lint": "eslint \"src/**/*.ts*\"",
+    "release": "np",
+    "start": "vite --open --mode ssr",
+    "test": "deno test --no-config src/",
+    "qwik": "qwik"
+  },
+  "dependencies": {
+    "@fluent/bundle": "^0.19.1"
+  },
+  "peerDependencies": {
+    "@qwik.dev/core": "^2.0.0-beta.38"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@qwik.dev/router": "^2.0.0-beta.38",
+    "@types/node": "24.10.0",
+    "eslint": "10.0.2",
+    "eslint-plugin-qwik": "^2.0.0-beta.38",
+    "globals": "17.0.0",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.56.1",
+    "vite": "7.3.1",
+    "vite-tsconfig-paths": "^4.3.2"
+  }
+}