@just-web/react-intl 1.1.1 → 1.2.2

package/dist/index.cjs

@@ -0,0 +1,176 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+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 __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let _just_web_formatjs = require("@just-web/formatjs");
+let react = require("react");
+react = __toESM(react, 1);
+let react_intl = require("react-intl");
+
+//#region ../../node_modules/.pnpm/@unional+gizmo@2.3.0/node_modules/@unional/gizmo/esm/define.js
+function define(plugin) {
+	return plugin;
+}
+function defineDeps() {
+	return {
+		require: defineDeps,
+		optional: defineDeps
+	};
+}
+define.require = defineDeps;
+define.optional = defineDeps;
+
+//#endregion
+//#region ../../node_modules/.pnpm/type-plus@8.0.0-beta.7/node_modules/type-plus/esm/type-guard/is_type.js
+function isType(subject, validator) {
+	return validator ? !!validator(subject) : true;
+}
+/**
+* @deprecated use `isType<T>()` or `testType.true<T>()` instead
+*/
+isType.t = (subject) => subject === void 0 || subject === true;
+/**
+* @deprecated use `isType<T>()` or `testType.false<T>()` instead
+*/
+isType.f = (subject) => subject === void 0 || subject === false;
+function isNever(_subject) {
+	return true;
+}
+isType.never = isNever;
+/**
+* Are types A and B equals/not equals.
+* Easier to use than `isType.t<>()` and `isType.f<>()`,
+* when doing type level only equality comparison as you don't have to import `Equal<>`.
+*
+* @deprecated use `testType.equal()` instead
+*/
+isType.equal = () => {};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unional+gizmo@2.3.0/node_modules/@unional/gizmo/esm/incubate.js
+const closableApps = /* @__PURE__ */ new Map();
+function addCloser(app, closer) {
+	if (typeof closer === "function") {
+		const closers = closableApps.get(app) ?? [];
+		closers.push(closer);
+		closableApps.set(app, closers);
+	}
+}
+function incubate(base) {
+	const dependencies = [];
+	if (base) dependencies.push({ instance: base });
+	let initFn;
+	return {
+		with(gizmo) {
+			dependencies.push({ gizmo });
+			return this;
+		},
+		merge(instance) {
+			dependencies.push({ instance });
+			return this;
+		},
+		init(initializer) {
+			initFn = initializer;
+			return this;
+		},
+		async create(start) {
+			const result = { async load(_identifier) {
+				return result;
+			} };
+			for (const dep of dependencies) if (isType(dep, (d) => !!d.gizmo)) await injectGizmo(result, dep.gizmo);
+			else Object.assign(result, dep.instance);
+			if (initFn) addCloser(result, await initFn(result));
+			if (start) addCloser(result, await start(result));
+			delete result["load"];
+			return result;
+		}
+	};
+}
+/**
+* Invokes any cleanup functions of the gizmo and its dependents.
+*
+* The gizmo is not destroyed as in other languages,
+* as there is no destructor or ability to tap into the garbage collector of JavaScript.
+*
+* But nonetheless, the cleanup functions are used to close resources such as network connections,
+* strong map, cache, etc.
+*
+* The gizmo should not be used after cleanup.
+*/
+incubate.cleanup = (app) => {
+	const closers = closableApps.get(app);
+	if (closers) closers.forEach((c) => void c());
+};
+async function injectGizmo(result, gizmo) {
+	const gizmoResult = await gizmo.create(result);
+	if (Array.isArray(gizmoResult)) {
+		const [value, start] = gizmoResult;
+		if (start) addCloser(result, await start());
+		Object.assign(result, value);
+		return value;
+	}
+	Object.assign(result, gizmoResult);
+	return gizmoResult;
+}
+
+//#endregion
+//#region src/react_intl_gizmo.tsx
+const reactIntlGizmoFn = define((options) => ({
+	static: define.require().optional(),
+	async create(ctx) {
+		const formatjs = await getFormatjs(ctx, options);
+		return [{ react_intl: { intl: formatjs.intl } }, () => ctx.react.providers.register(({ children }) => /* @__PURE__ */ react.default.createElement(react_intl.RawIntlProvider, { value: formatjs.intl }, children))];
+	}
+}));
+async function getFormatjs(ctx, options) {
+	if (ctx.formatjs) return ctx.formatjs;
+	if (!options) throw new Error("options is required when there is no formatjs gizmo");
+	return (await incubate().with((0, _just_web_formatjs.formatJSGizmoFn)(options)).create()).formatjs;
+}
+
+//#endregion
+exports.reactIntlGizmoFn = reactIntlGizmoFn;
+Object.keys(react_intl).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return react_intl[k]; }
+  });
+});

package/dist/index.d.cts

@@ -0,0 +1,218 @@
+import { FormatJSGizmoOptions } from "@just-web/formatjs";
+import { IntlShape } from "react-intl";
+export * from "react-intl";
+//#region ../../node_modules/.pnpm/@unional+gizmo@2.3.0/node_modules/@unional/gizmo/esm/types.d.ts
+declare const _type: unique symbol;
+type Gizmo<Static extends DepBuilder<unknown, unknown> | unknown = unknown, Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown = unknown, Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, unknown> | void = Record<string | symbol, any> | void> = GizmoBase<Result> | GizmoStatic<Static, Result> | GizmoDynamic<Dynamic, Result> | GizmoBoth<Static, Dynamic, Result>;
+type GizmoBase<Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, unknown> | void = Record<string | symbol, any> | void> = {
+  create(): Result | Promise<Result>;
+};
+type GizmoStatic<Static extends DepBuilder<unknown, unknown> | unknown = unknown, Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, unknown> | void = Record<string | symbol, any> | void> = {
+  readonly static: Static;
+  create(ctx: DefineContext<Static, unknown>): Result | Promise<Result>;
+};
+type GizmoDynamic<Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown = unknown, Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, unknown> | void = Record<string | symbol, any> | void> = {
+  readonly dynamic: Dynamic;
+  create(ctx: DefineContext<unknown, Dynamic>): Result | Promise<Result>;
+};
+type GizmoBoth<Static extends DepBuilder<unknown, unknown> | unknown = unknown, Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown = unknown, Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, unknown> | void = Record<string | symbol, any> | void> = {
+  readonly static: Static;
+  readonly dynamic: Dynamic;
+  create(ctx: DefineContext<Static, Dynamic>): Result | Promise<Result>;
+};
+type InferAllGizmo<D extends Gizmo | ((...args: any[]) => Gizmo)> = D extends ((...args: any[]) => Gizmo) ? InferGizmo<ReturnType<D>> : D extends Gizmo ? InferGizmo<D> : never;
+type InferGizmo<D extends Gizmo> = D extends Gizmo ? ReturnType<D['create']> extends (infer R) ? R extends Promise<[infer X extends Record<string | symbol, unknown>, unknown]> ? Awaited<X> : R extends Promise<[infer X extends Record<string | symbol, unknown>]> ? Awaited<X> : R extends [infer X extends Record<string | symbol, unknown>, unknown] ? X : R extends [infer X extends Record<string | symbol, unknown>] ? X : R extends Record<string | symbol, any> ? Awaited<R> : never : never : unknown;
+type DefineContext<Static extends DepBuilder<unknown, unknown> | unknown, Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown> = Dynamic extends Record<string, DepBuilder<unknown, unknown>> ? ExtractDep<Static> & DynamicLoader<Dynamic> : ExtractDep<Static>;
+/**
+ * Define the `ctx.load` function.
+ */
+type DynamicLoader<Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown> = {
+  load<I extends keyof Dynamic>(identifier: I): Promise<ExtractDep<Dynamic[I]>>;
+};
+type DepBuilder<R, O> = {
+  [_type]: {
+    require: R;
+    optional: O;
+  };
+  require: {
+    /**
+     * Define a gizmo as a require dependency by specifying the type.
+     *
+     * ```ts
+     * const gizmo = define({
+     *   static: define.require<SomeGizmo>()
+     * })
+     * ```
+     */
+    <Require extends Record<string | symbol, unknown>>(): DepBuilder<R & Require, O>;
+    /**
+     * Define a gizmo as a require dependency by passing in the gizmo directly.
+     *
+     * ```ts
+     * const gizmo = define({
+     *   static: define.require(someGizmo)
+     * })
+     * ```
+     */
+    <G extends Gizmo | ((...args: any[]) => Gizmo)>(gizmo: G): DepBuilder<R & InferAllGizmo<G>, O>;
+  };
+  optional: {
+    /**
+     * Define a gizmo as an optional dependency by specifying the type.
+     *
+     * ```ts
+     * const gizmo = define({
+     *   static: define.optional<SomeGizmo>()
+     * })
+     * ```
+     */
+    <Optional extends Record<string | symbol, unknown>>(): DepBuilder<R, O & Optional>;
+    /**
+     * Define a gizmo as an optional dependency by passing in the gizmo directly.
+     *
+     * ```ts
+     * const gizmo = define({
+     *   static: define.optional(someGizmo)
+     * })
+     * ```
+     */
+    <G extends Gizmo | ((...args: any[]) => Gizmo)>(gizmo: G): DepBuilder<R, O & InferAllGizmo<G>>;
+  };
+};
+/**
+ * Extract the dependencies from a dep builder.
+ */
+type ExtractDep<D extends DepBuilder<unknown, unknown> | unknown> = D extends DepBuilder<unknown, unknown> ? unknown extends D[typeof _type]['require'] ? unknown extends D[typeof _type]['optional'] ? unknown : Partial<D[typeof _type]['optional']> : unknown extends D[typeof _type]['optional'] ? D[typeof _type]['require'] : D[typeof _type]['require'] & Partial<D[typeof _type]['optional']> : unknown;
+//#endregion
+//#region ../../node_modules/.pnpm/@unional+gizmo@2.3.0/node_modules/@unional/gizmo/esm/define.d.ts
+/**
+ * Define a gizmo with both static and dynamic dependencies.
+ *
+ * ```ts
+ * const gizmo = define({
+ *   static: define.require(...),
+ *   dynamic: {
+ *     foo: define.optional(...)
+ *   },
+ *   async create(ctx) { ... }
+ * })
+ * ```
+ */
+declare function define<Static extends DepBuilder<unknown, unknown>, Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown, Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmo: GizmoBoth<Static, Dynamic, Result>): typeof gizmo;
+/**
+ * Define a gizmo with static dependencies.
+ *
+ * ```ts
+ * const gizmo = define({
+ *   static: define.require(fooGizmo).optional(booGizmo),
+ *   async create({ foo, boo }) { ... }
+ * })
+ * ```
+ */
+declare function define<Static extends DepBuilder<unknown, unknown>, Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmo: GizmoStatic<Static, Result>): typeof gizmo;
+/**
+ * Define a gizmo with dynamic dependencies.
+ *
+ * ```ts
+ * const gizmo = define({
+ *   dynamic: {
+ *     foo: define.optional(...)
+ *   },
+ *   async create(ctx) {
+ *     const d = await ctx.load('foo')
+ *     return { ... }
+ *   }
+ * })
+ * ```
+ */
+declare function define<Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown, Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmo: GizmoDynamic<Dynamic, Result>): typeof gizmo;
+/**
+ * Define a gizmo with no dependencies.
+ *
+ * ```ts
+ * const gizmo = define({
+ *   async create() { ... }
+ * })
+ * ```
+ */
+declare function define<Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmo: GizmoBase<Result>): typeof gizmo;
+/**
+ * Define a gizmo function with both static and dynamic dependencies.
+ *
+ * ```ts
+ * const gizmo = define((params) => ({
+ *   static: define.require(...),
+ *   dynamic: {
+ *     foo: define.optional(...)
+ *   },
+ *   async create(ctx) { ... }
+ * }))
+ * ```
+ */
+declare function define<Static extends DepBuilder<unknown, unknown>, Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown, Params extends unknown[], Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmoFn: (...args: Params) => GizmoBoth<Static, Dynamic, Result>): typeof gizmoFn;
+/**
+ * Define a gizmo function with static dependencies.
+ *
+ * ```ts
+ * const gizmo = define((params) => ({
+ *   static: define.require(fooGizmo).optional(booGizmo),
+ *   async create({ foo, boo }) { ... }
+ * }))
+ * ```
+ */
+declare function define<Static extends DepBuilder<unknown, unknown>, Params extends unknown[], Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmoFn: (...args: Params) => GizmoStatic<Static, Result>): typeof gizmoFn;
+/**
+ * Define a gizmo function with dynamic dependencies.
+ *
+ * ```ts
+ * const gizmo = define((params) => ({
+ *   dynamic: {
+ *     foo: define.optional(...)
+ *   },
+ *   async create(ctx) {
+ *     const d = await ctx.load('foo')
+ *     return { ... }
+ *   }
+ * }))
+ * ```
+ */
+declare function define<Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown, Params extends unknown[], Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmoFn: (...args: Params) => GizmoDynamic<Dynamic, Result>): typeof gizmoFn;
+/**
+ * Define a gizmo function with no dependencies.
+ *
+ * ```ts
+ * const gizmo = define((params) => ({
+ *   async create() { ... }
+ * }))
+ * ```
+ */
+declare function define<Params extends unknown[], Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmoFn: (...args: Params) => GizmoBase<Result>): typeof gizmoFn;
+declare namespace define {
+  var require: {
+    <Require extends Record<string | symbol, unknown>>(): DepBuilder<Require, unknown>;
+    <G extends Gizmo | ((...args: any[]) => Gizmo)>(gizmo: G): DepBuilder<InferAllGizmo<G>, unknown>;
+  };
+  var optional: {
+    <Optional extends Record<string | symbol, unknown>>(): DepBuilder<unknown, Optional>;
+    <G extends Gizmo | ((...args: any[]) => Gizmo)>(gizmo: G): DepBuilder<unknown, InferAllGizmo<G>>;
+  };
+}
+declare namespace define {
+  type Infer<D extends Gizmo | ((...args: any[]) => Gizmo)> = InferAllGizmo<D>;
+}
+//#endregion
+//#region src/react_intl_gizmo.d.ts
+type ReactIntlGizmoOptions<T = string> = FormatJSGizmoOptions<T>;
+declare const reactIntlGizmoFn: <T = string>(options?: ReactIntlGizmoOptions<T> | undefined) => GizmoStatic<DepBuilder<ReactGizmo, {
+  formatjs: {
+    intl: import("@just-web/formatjs").IntlShape<unknown>;
+  };
+}>, [{
+  react_intl: {
+    intl: IntlShape;
+  };
+}, () => any]>;
+type ReactIntlGizmo = define.Infer<typeof reactIntlGizmoFn>;
+//#endregion
+export { ReactIntlGizmo, ReactIntlGizmoOptions, reactIntlGizmoFn };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../node_modules/.pnpm/@unional+gizmo@2.3.0/node_modules/@unional/gizmo/esm/types.d.ts","../../../node_modules/.pnpm/@unional+gizmo@2.3.0/node_modules/@unional/gizmo/esm/define.d.ts","../src/react_intl_gizmo.tsx"],"x_google_ignoreList":[0,1],"mappings":"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"}

package/dist/index.d.mts

@@ -0,0 +1,218 @@
+import { FormatJSGizmoOptions } from "@just-web/formatjs";
+import { IntlShape } from "react-intl";
+export * from "react-intl";
+//#region ../../node_modules/.pnpm/@unional+gizmo@2.3.0/node_modules/@unional/gizmo/esm/types.d.ts
+declare const _type: unique symbol;
+type Gizmo<Static extends DepBuilder<unknown, unknown> | unknown = unknown, Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown = unknown, Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, unknown> | void = Record<string | symbol, any> | void> = GizmoBase<Result> | GizmoStatic<Static, Result> | GizmoDynamic<Dynamic, Result> | GizmoBoth<Static, Dynamic, Result>;
+type GizmoBase<Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, unknown> | void = Record<string | symbol, any> | void> = {
+  create(): Result | Promise<Result>;
+};
+type GizmoStatic<Static extends DepBuilder<unknown, unknown> | unknown = unknown, Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, unknown> | void = Record<string | symbol, any> | void> = {
+  readonly static: Static;
+  create(ctx: DefineContext<Static, unknown>): Result | Promise<Result>;
+};
+type GizmoDynamic<Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown = unknown, Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, unknown> | void = Record<string | symbol, any> | void> = {
+  readonly dynamic: Dynamic;
+  create(ctx: DefineContext<unknown, Dynamic>): Result | Promise<Result>;
+};
+type GizmoBoth<Static extends DepBuilder<unknown, unknown> | unknown = unknown, Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown = unknown, Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, unknown> | void = Record<string | symbol, any> | void> = {
+  readonly static: Static;
+  readonly dynamic: Dynamic;
+  create(ctx: DefineContext<Static, Dynamic>): Result | Promise<Result>;
+};
+type InferAllGizmo<D extends Gizmo | ((...args: any[]) => Gizmo)> = D extends ((...args: any[]) => Gizmo) ? InferGizmo<ReturnType<D>> : D extends Gizmo ? InferGizmo<D> : never;
+type InferGizmo<D extends Gizmo> = D extends Gizmo ? ReturnType<D['create']> extends (infer R) ? R extends Promise<[infer X extends Record<string | symbol, unknown>, unknown]> ? Awaited<X> : R extends Promise<[infer X extends Record<string | symbol, unknown>]> ? Awaited<X> : R extends [infer X extends Record<string | symbol, unknown>, unknown] ? X : R extends [infer X extends Record<string | symbol, unknown>] ? X : R extends Record<string | symbol, any> ? Awaited<R> : never : never : unknown;
+type DefineContext<Static extends DepBuilder<unknown, unknown> | unknown, Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown> = Dynamic extends Record<string, DepBuilder<unknown, unknown>> ? ExtractDep<Static> & DynamicLoader<Dynamic> : ExtractDep<Static>;
+/**
+ * Define the `ctx.load` function.
+ */
+type DynamicLoader<Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown> = {
+  load<I extends keyof Dynamic>(identifier: I): Promise<ExtractDep<Dynamic[I]>>;
+};
+type DepBuilder<R, O> = {
+  [_type]: {
+    require: R;
+    optional: O;
+  };
+  require: {
+    /**
+     * Define a gizmo as a require dependency by specifying the type.
+     *
+     * ```ts
+     * const gizmo = define({
+     *   static: define.require<SomeGizmo>()
+     * })
+     * ```
+     */
+    <Require extends Record<string | symbol, unknown>>(): DepBuilder<R & Require, O>;
+    /**
+     * Define a gizmo as a require dependency by passing in the gizmo directly.
+     *
+     * ```ts
+     * const gizmo = define({
+     *   static: define.require(someGizmo)
+     * })
+     * ```
+     */
+    <G extends Gizmo | ((...args: any[]) => Gizmo)>(gizmo: G): DepBuilder<R & InferAllGizmo<G>, O>;
+  };
+  optional: {
+    /**
+     * Define a gizmo as an optional dependency by specifying the type.
+     *
+     * ```ts
+     * const gizmo = define({
+     *   static: define.optional<SomeGizmo>()
+     * })
+     * ```
+     */
+    <Optional extends Record<string | symbol, unknown>>(): DepBuilder<R, O & Optional>;
+    /**
+     * Define a gizmo as an optional dependency by passing in the gizmo directly.
+     *
+     * ```ts
+     * const gizmo = define({
+     *   static: define.optional(someGizmo)
+     * })
+     * ```
+     */
+    <G extends Gizmo | ((...args: any[]) => Gizmo)>(gizmo: G): DepBuilder<R, O & InferAllGizmo<G>>;
+  };
+};
+/**
+ * Extract the dependencies from a dep builder.
+ */
+type ExtractDep<D extends DepBuilder<unknown, unknown> | unknown> = D extends DepBuilder<unknown, unknown> ? unknown extends D[typeof _type]['require'] ? unknown extends D[typeof _type]['optional'] ? unknown : Partial<D[typeof _type]['optional']> : unknown extends D[typeof _type]['optional'] ? D[typeof _type]['require'] : D[typeof _type]['require'] & Partial<D[typeof _type]['optional']> : unknown;
+//#endregion
+//#region ../../node_modules/.pnpm/@unional+gizmo@2.3.0/node_modules/@unional/gizmo/esm/define.d.ts
+/**
+ * Define a gizmo with both static and dynamic dependencies.
+ *
+ * ```ts
+ * const gizmo = define({
+ *   static: define.require(...),
+ *   dynamic: {
+ *     foo: define.optional(...)
+ *   },
+ *   async create(ctx) { ... }
+ * })
+ * ```
+ */
+declare function define<Static extends DepBuilder<unknown, unknown>, Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown, Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmo: GizmoBoth<Static, Dynamic, Result>): typeof gizmo;
+/**
+ * Define a gizmo with static dependencies.
+ *
+ * ```ts
+ * const gizmo = define({
+ *   static: define.require(fooGizmo).optional(booGizmo),
+ *   async create({ foo, boo }) { ... }
+ * })
+ * ```
+ */
+declare function define<Static extends DepBuilder<unknown, unknown>, Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmo: GizmoStatic<Static, Result>): typeof gizmo;
+/**
+ * Define a gizmo with dynamic dependencies.
+ *
+ * ```ts
+ * const gizmo = define({
+ *   dynamic: {
+ *     foo: define.optional(...)
+ *   },
+ *   async create(ctx) {
+ *     const d = await ctx.load('foo')
+ *     return { ... }
+ *   }
+ * })
+ * ```
+ */
+declare function define<Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown, Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmo: GizmoDynamic<Dynamic, Result>): typeof gizmo;
+/**
+ * Define a gizmo with no dependencies.
+ *
+ * ```ts
+ * const gizmo = define({
+ *   async create() { ... }
+ * })
+ * ```
+ */
+declare function define<Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmo: GizmoBase<Result>): typeof gizmo;
+/**
+ * Define a gizmo function with both static and dynamic dependencies.
+ *
+ * ```ts
+ * const gizmo = define((params) => ({
+ *   static: define.require(...),
+ *   dynamic: {
+ *     foo: define.optional(...)
+ *   },
+ *   async create(ctx) { ... }
+ * }))
+ * ```
+ */
+declare function define<Static extends DepBuilder<unknown, unknown>, Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown, Params extends unknown[], Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmoFn: (...args: Params) => GizmoBoth<Static, Dynamic, Result>): typeof gizmoFn;
+/**
+ * Define a gizmo function with static dependencies.
+ *
+ * ```ts
+ * const gizmo = define((params) => ({
+ *   static: define.require(fooGizmo).optional(booGizmo),
+ *   async create({ foo, boo }) { ... }
+ * }))
+ * ```
+ */
+declare function define<Static extends DepBuilder<unknown, unknown>, Params extends unknown[], Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmoFn: (...args: Params) => GizmoStatic<Static, Result>): typeof gizmoFn;
+/**
+ * Define a gizmo function with dynamic dependencies.
+ *
+ * ```ts
+ * const gizmo = define((params) => ({
+ *   dynamic: {
+ *     foo: define.optional(...)
+ *   },
+ *   async create(ctx) {
+ *     const d = await ctx.load('foo')
+ *     return { ... }
+ *   }
+ * }))
+ * ```
+ */
+declare function define<Dynamic extends Record<string, DepBuilder<unknown, unknown>> | unknown, Params extends unknown[], Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmoFn: (...args: Params) => GizmoDynamic<Dynamic, Result>): typeof gizmoFn;
+/**
+ * Define a gizmo function with no dependencies.
+ *
+ * ```ts
+ * const gizmo = define((params) => ({
+ *   async create() { ... }
+ * }))
+ * ```
+ */
+declare function define<Params extends unknown[], Result extends [result: Record<string | symbol, unknown>, start?: () => unknown] | Record<string | symbol, any> | void>(gizmoFn: (...args: Params) => GizmoBase<Result>): typeof gizmoFn;
+declare namespace define {
+  var require: {
+    <Require extends Record<string | symbol, unknown>>(): DepBuilder<Require, unknown>;
+    <G extends Gizmo | ((...args: any[]) => Gizmo)>(gizmo: G): DepBuilder<InferAllGizmo<G>, unknown>;
+  };
+  var optional: {
+    <Optional extends Record<string | symbol, unknown>>(): DepBuilder<unknown, Optional>;
+    <G extends Gizmo | ((...args: any[]) => Gizmo)>(gizmo: G): DepBuilder<unknown, InferAllGizmo<G>>;
+  };
+}
+declare namespace define {
+  type Infer<D extends Gizmo | ((...args: any[]) => Gizmo)> = InferAllGizmo<D>;
+}
+//#endregion
+//#region src/react_intl_gizmo.d.ts
+type ReactIntlGizmoOptions<T = string> = FormatJSGizmoOptions<T>;
+declare const reactIntlGizmoFn: <T = string>(options?: ReactIntlGizmoOptions<T> | undefined) => GizmoStatic<DepBuilder<ReactGizmo, {
+  formatjs: {
+    intl: import("@just-web/formatjs").IntlShape<unknown>;
+  };
+}>, [{
+  react_intl: {
+    intl: IntlShape;
+  };
+}, () => any]>;
+type ReactIntlGizmo = define.Infer<typeof reactIntlGizmoFn>;
+//#endregion
+export { ReactIntlGizmo, ReactIntlGizmoOptions, reactIntlGizmoFn };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../node_modules/.pnpm/@unional+gizmo@2.3.0/node_modules/@unional/gizmo/esm/types.d.ts","../../../node_modules/.pnpm/@unional+gizmo@2.3.0/node_modules/@unional/gizmo/esm/define.d.ts","../src/react_intl_gizmo.tsx"],"x_google_ignoreList":[0,1],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,130 @@
+import { formatJSGizmoFn } from "@just-web/formatjs";
+import React from "react";
+import { RawIntlProvider } from "react-intl";
+
+export * from "react-intl"
+
+//#region ../../node_modules/.pnpm/@unional+gizmo@2.3.0/node_modules/@unional/gizmo/esm/define.js
+function define(plugin) {
+	return plugin;
+}
+function defineDeps() {
+	return {
+		require: defineDeps,
+		optional: defineDeps
+	};
+}
+define.require = defineDeps;
+define.optional = defineDeps;
+
+//#endregion
+//#region ../../node_modules/.pnpm/type-plus@8.0.0-beta.7/node_modules/type-plus/esm/type-guard/is_type.js
+function isType(subject, validator) {
+	return validator ? !!validator(subject) : true;
+}
+/**
+* @deprecated use `isType<T>()` or `testType.true<T>()` instead
+*/
+isType.t = (subject) => subject === void 0 || subject === true;
+/**
+* @deprecated use `isType<T>()` or `testType.false<T>()` instead
+*/
+isType.f = (subject) => subject === void 0 || subject === false;
+function isNever(_subject) {
+	return true;
+}
+isType.never = isNever;
+/**
+* Are types A and B equals/not equals.
+* Easier to use than `isType.t<>()` and `isType.f<>()`,
+* when doing type level only equality comparison as you don't have to import `Equal<>`.
+*
+* @deprecated use `testType.equal()` instead
+*/
+isType.equal = () => {};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unional+gizmo@2.3.0/node_modules/@unional/gizmo/esm/incubate.js
+const closableApps = /* @__PURE__ */ new Map();
+function addCloser(app, closer) {
+	if (typeof closer === "function") {
+		const closers = closableApps.get(app) ?? [];
+		closers.push(closer);
+		closableApps.set(app, closers);
+	}
+}
+function incubate(base) {
+	const dependencies = [];
+	if (base) dependencies.push({ instance: base });
+	let initFn;
+	return {
+		with(gizmo) {
+			dependencies.push({ gizmo });
+			return this;
+		},
+		merge(instance) {
+			dependencies.push({ instance });
+			return this;
+		},
+		init(initializer) {
+			initFn = initializer;
+			return this;
+		},
+		async create(start) {
+			const result = { async load(_identifier) {
+				return result;
+			} };
+			for (const dep of dependencies) if (isType(dep, (d) => !!d.gizmo)) await injectGizmo(result, dep.gizmo);
+			else Object.assign(result, dep.instance);
+			if (initFn) addCloser(result, await initFn(result));
+			if (start) addCloser(result, await start(result));
+			delete result["load"];
+			return result;
+		}
+	};
+}
+/**
+* Invokes any cleanup functions of the gizmo and its dependents.
+*
+* The gizmo is not destroyed as in other languages,
+* as there is no destructor or ability to tap into the garbage collector of JavaScript.
+*
+* But nonetheless, the cleanup functions are used to close resources such as network connections,
+* strong map, cache, etc.
+*
+* The gizmo should not be used after cleanup.
+*/
+incubate.cleanup = (app) => {
+	const closers = closableApps.get(app);
+	if (closers) closers.forEach((c) => void c());
+};
+async function injectGizmo(result, gizmo) {
+	const gizmoResult = await gizmo.create(result);
+	if (Array.isArray(gizmoResult)) {
+		const [value, start] = gizmoResult;
+		if (start) addCloser(result, await start());
+		Object.assign(result, value);
+		return value;
+	}
+	Object.assign(result, gizmoResult);
+	return gizmoResult;
+}
+
+//#endregion
+//#region src/react_intl_gizmo.tsx
+const reactIntlGizmoFn = define((options) => ({
+	static: define.require().optional(),
+	async create(ctx) {
+		const formatjs = await getFormatjs(ctx, options);
+		return [{ react_intl: { intl: formatjs.intl } }, () => ctx.react.providers.register(({ children }) => /* @__PURE__ */ React.createElement(RawIntlProvider, { value: formatjs.intl }, children))];
+	}
+}));
+async function getFormatjs(ctx, options) {
+	if (ctx.formatjs) return ctx.formatjs;
+	if (!options) throw new Error("options is required when there is no formatjs gizmo");
+	return (await incubate().with(formatJSGizmoFn(options)).create()).formatjs;
+}
+
+//#endregion
+export { reactIntlGizmoFn };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../node_modules/.pnpm/@unional+gizmo@2.3.0/node_modules/@unional/gizmo/esm/define.js","../../../node_modules/.pnpm/type-plus@8.0.0-beta.7/node_modules/type-plus/esm/type-guard/is_type.js","../../../node_modules/.pnpm/@unional+gizmo@2.3.0/node_modules/@unional/gizmo/esm/incubate.js","../src/react_intl_gizmo.tsx"],"sourcesContent":["export function define(plugin) {\n    return plugin;\n}\nfunction defineDeps() {\n    return {\n        require: defineDeps,\n        optional: defineDeps,\n    };\n}\ndefine.require = defineDeps;\ndefine.optional = defineDeps;\n//# sourceMappingURL=define.js.map","export function isType(subject, validator) {\n    return validator ? !!validator(subject) : true;\n}\n/**\n * @deprecated use `isType<T>()` or `testType.true<T>()` instead\n */\nisType.t = (subject) => subject === undefined || subject === true;\n/**\n * @deprecated use `isType<T>()` or `testType.false<T>()` instead\n */\nisType.f = (subject) => subject === undefined || subject === false;\nfunction isNever(_subject) {\n    return true;\n}\nisType.never = isNever;\n/**\n * Are types A and B equals/not equals.\n * Easier to use than `isType.t<>()` and `isType.f<>()`,\n * when doing type level only equality comparison as you don't have to import `Equal<>`.\n *\n * @deprecated use `testType.equal()` instead\n */\nisType.equal = () => { };\n//# sourceMappingURL=is_type.js.map","import { isType } from 'type-plus';\nconst closableApps = new Map();\nfunction addCloser(app, closer) {\n    if (typeof closer === 'function') {\n        const closers = closableApps.get(app) ?? [];\n        closers.push(closer);\n        closableApps.set(app, closers);\n    }\n}\nexport function incubate(base) {\n    const dependencies = [];\n    if (base)\n        dependencies.push({ instance: base });\n    let initFn;\n    return {\n        with(gizmo) {\n            dependencies.push({ gizmo });\n            return this;\n        },\n        merge(instance) {\n            dependencies.push({ instance });\n            return this;\n        },\n        init(initializer) {\n            initFn = initializer;\n            return this;\n        },\n        async create(start) {\n            const result = {\n                async load(_identifier) {\n                    return result;\n                },\n            };\n            for (const dep of dependencies) {\n                if (isType(dep, (d) => !!d.gizmo)) {\n                    await injectGizmo(result, dep.gizmo);\n                }\n                else {\n                    Object.assign(result, dep.instance);\n                }\n            }\n            if (initFn) {\n                addCloser(result, await initFn(result));\n            }\n            if (start) {\n                addCloser(result, await start(result));\n            }\n            // biome-ignore lint/performance/noDelete: specific implementation\n            delete result['load'];\n            return result;\n        },\n    };\n}\n/**\n * Invokes any cleanup functions of the gizmo and its dependents.\n *\n * The gizmo is not destroyed as in other languages,\n * as there is no destructor or ability to tap into the garbage collector of JavaScript.\n *\n * But nonetheless, the cleanup functions are used to close resources such as network connections,\n * strong map, cache, etc.\n *\n * The gizmo should not be used after cleanup.\n */\nincubate.cleanup = (app) => {\n    const closers = closableApps.get(app);\n    if (closers) {\n        closers.forEach((c) => void c());\n    }\n};\nasync function injectGizmo(result, gizmo) {\n    const gizmoResult = await gizmo.create(result);\n    if (Array.isArray(gizmoResult)) {\n        const [value, start] = gizmoResult;\n        if (start) {\n            addCloser(result, await start());\n        }\n        Object.assign(result, value);\n        return value;\n    }\n    Object.assign(result, gizmoResult);\n    return gizmoResult;\n}\n//# sourceMappingURL=incubate.js.map","import { define, incubate } from '@just-web/app'\nimport { type FormatJSGizmo, type FormatJSGizmoOptions, formatJSGizmoFn } from '@just-web/formatjs'\nimport React from 'react'\nimport { type IntlShape, RawIntlProvider } from 'react-intl'\nimport type { ReactGizmo } from '../../react/dist/hooks/store'\n\nexport type ReactIntlGizmoOptions<T = string> = FormatJSGizmoOptions<T>\n\nexport const reactIntlGizmoFn = define(<T = string>(options?: ReactIntlGizmoOptions<T>) => ({\n\tstatic: define.require<ReactGizmo>().optional<FormatJSGizmo>(),\n\tasync create(ctx: ReactGizmo & Partial<FormatJSGizmo>) {\n\t\tconst formatjs = await getFormatjs(ctx, options)\n\t\treturn [\n\t\t\t{\n\t\t\t\treact_intl: {\n\t\t\t\t\tintl: formatjs.intl as IntlShape\n\t\t\t\t}\n\t\t\t},\n\t\t\t() =>\n\t\t\t\tctx.react.providers.register(({ children }) => (\n\t\t\t\t\t<RawIntlProvider value={formatjs.intl as IntlShape}>{children}</RawIntlProvider>\n\t\t\t\t))\n\t\t]\n\t}\n}))\n\nexport type ReactIntlGizmo = define.Infer<typeof reactIntlGizmoFn>\n\nasync function getFormatjs(ctx: Partial<FormatJSGizmo>, options: ReactIntlGizmoOptions<any> | undefined) {\n\tif (ctx.formatjs) return ctx.formatjs\n\tif (!options) throw new Error('options is required when there is no formatjs gizmo')\n\treturn (await incubate().with(formatJSGizmoFn(options)).create()).formatjs\n}\n"],"x_google_ignoreList":[0,1,2],"mappings":";;;;;;;AAAA,SAAgB,OAAO,QAAQ;CAC3B,OAAO;AACX;AACA,SAAS,aAAa;CAClB,OAAO;EACH,SAAS;EACT,UAAU;CACd;AACJ;AACA,OAAO,UAAU;AACjB,OAAO,WAAW;;;;ACVlB,SAAgB,OAAO,SAAS,WAAW;CACvC,OAAO,YAAY,CAAC,CAAC,UAAU,OAAO,IAAI;AAC9C;;;;AAIA,OAAO,KAAK,YAAY,YAAY,UAAa,YAAY;;;;AAI7D,OAAO,KAAK,YAAY,YAAY,UAAa,YAAY;AAC7D,SAAS,QAAQ,UAAU;CACvB,OAAO;AACX;AACA,OAAO,QAAQ;;;;;;;;AAQf,OAAO,cAAc,CAAE;;;;ACrBvB,MAAM,+BAAe,IAAI,IAAI;AAC7B,SAAS,UAAU,KAAK,QAAQ;CAC5B,IAAI,OAAO,WAAW,YAAY;EAC9B,MAAM,UAAU,aAAa,IAAI,GAAG,KAAK,CAAC;EAC1C,QAAQ,KAAK,MAAM;EACnB,aAAa,IAAI,KAAK,OAAO;CACjC;AACJ;AACA,SAAgB,SAAS,MAAM;CAC3B,MAAM,eAAe,CAAC;CACtB,IAAI,MACA,aAAa,KAAK,EAAE,UAAU,KAAK,CAAC;CACxC,IAAI;CACJ,OAAO;EACH,KAAK,OAAO;GACR,aAAa,KAAK,EAAE,MAAM,CAAC;GAC3B,OAAO;EACX;EACA,MAAM,UAAU;GACZ,aAAa,KAAK,EAAE,SAAS,CAAC;GAC9B,OAAO;EACX;EACA,KAAK,aAAa;GACd,SAAS;GACT,OAAO;EACX;EACA,MAAM,OAAO,OAAO;GAChB,MAAM,SAAS,EACX,MAAM,KAAK,aAAa;IACpB,OAAO;GACX,EACJ;GACA,KAAK,MAAM,OAAO,cACd,IAAI,OAAO,MAAM,MAAM,CAAC,CAAC,EAAE,KAAK,GAC5B,MAAM,YAAY,QAAQ,IAAI,KAAK;QAGnC,OAAO,OAAO,QAAQ,IAAI,QAAQ;GAG1C,IAAI,QACA,UAAU,QAAQ,MAAM,OAAO,MAAM,CAAC;GAE1C,IAAI,OACA,UAAU,QAAQ,MAAM,MAAM,MAAM,CAAC;GAGzC,OAAO,OAAO;GACd,OAAO;EACX;CACJ;AACJ;;;;;;;;;;;;AAYA,SAAS,WAAW,QAAQ;CACxB,MAAM,UAAU,aAAa,IAAI,GAAG;CACpC,IAAI,SACA,QAAQ,SAAS,MAAM,KAAK,EAAE,CAAC;AAEvC;AACA,eAAe,YAAY,QAAQ,OAAO;CACtC,MAAM,cAAc,MAAM,MAAM,OAAO,MAAM;CAC7C,IAAI,MAAM,QAAQ,WAAW,GAAG;EAC5B,MAAM,CAAC,OAAO,SAAS;EACvB,IAAI,OACA,UAAU,QAAQ,MAAM,MAAM,CAAC;EAEnC,OAAO,OAAO,QAAQ,KAAK;EAC3B,OAAO;CACX;CACA,OAAO,OAAO,QAAQ,WAAW;CACjC,OAAO;AACX;;;;AC1EA,MAAa,mBAAmB,QAAoB,aAAwC;CAC3F,QAAQ,OAAO,QAAoB,CAAC,CAAC,SAAwB;CAC7D,MAAM,OAAO,KAA0C;EACtD,MAAM,WAAW,MAAM,YAAY,KAAK,OAAO;EAC/C,OAAO,CACN,EACC,YAAY,EACX,MAAM,SAAS,KAChB,EACD,SAEC,IAAI,MAAM,UAAU,UAAU,EAAE,eAC/B,oCAAC,iBAAD,EAAiB,OAAO,SAAS,KAA8C,GAA1B,QAA0B,CAC/E,CACH;CACD;AACD,EAAE;AAIF,eAAe,YAAY,KAA6B,SAAiD;CACxG,IAAI,IAAI,UAAU,OAAO,IAAI;CAC7B,IAAI,CAAC,SAAS,MAAM,IAAI,MAAM,qDAAqD;CACnF,QAAQ,MAAM,SAAS,CAAC,CAAC,KAAK,gBAAgB,OAAO,CAAC,CAAC,CAAC,OAAO,EAAC,CAAE;AACnE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@just-web/react-intl",
-  "version": "1.1.1",
+  "version": "1.2.2",
   "description": "react-intl gizmo for just-web applications",
   "keywords": [
     "just-web",
@@ -26,115 +26,71 @@
   "exports": {
     ".": {
       "import": {
-        "types": "./esm/index.d.ts",
-        "default": "./esm/index.js"
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
       },
       "require": {
-        "types": "./cjs/index.d.ts",
-        "default": "./cjs/index.js"
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
       },
-      "default": "./esm/index.js"
-    },
-    "./testing": {
-      "import": {
-        "types": "./esm/testing/index.d.ts",
-        "default": "./esm/testing/index.js"
-      },
-      "require": {
-        "types": "./cjs/testing/index.d.ts",
-        "require": "./cjs/testing/index.js"
-      },
-      "default": "./esm/testing/index.js"
+      "default": "./dist/index.mjs"
     }
   },
-  "main": "./cjs/index.js",
-  "module": "./esm/index.js",
-  "types": "./cjs/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "files": [
-    "cjs",
-    "esm",
-    "testing",
-    "ts",
+    "dist",
+    "src",
     "!**/*.{spec,test,unit,accept,integrate,system,perf,stress}.*",
     "!**/*.stories.*"
   ],
   "dependencies": {
-    "@just-web/formatjs": "^1.0.2",
+    "@just-web/formatjs": "^1.1.2",
     "react-intl": "^6.4.2"
   },
   "devDependencies": {
-    "@just-web/app": "^7.1.5",
-    "@repobuddy/jest": "^3.3.0",
-    "@repobuddy/typescript": "^1.2.0",
+    "@just-web/app": "^7.3.2",
+    "@repobuddy/typescript": "^2.1.0",
     "@size-limit/preset-small-lib": "~8.2.0",
-    "@storybook/addon-actions": "^7.0.6",
-    "@storybook/addon-backgrounds": "^7.0.6",
-    "@storybook/addon-console": "~2.0.0",
-    "@storybook/addon-docs": "^7.0.6",
-    "@storybook/addon-essentials": "^7.0.6",
-    "@storybook/addon-interactions": "^7.0.6",
-    "@storybook/addon-links": "^7.0.6",
-    "@storybook/addon-measure": "^7.0.6",
-    "@storybook/addon-outline": "^7.0.6",
-    "@storybook/addon-storysource": "^7.0.6",
-    "@storybook/addon-styling": "^1.0.1",
-    "@storybook/addons": "^7.0.6",
-    "@storybook/channel-postmessage": "^7.0.6",
-    "@storybook/channel-websocket": "^7.0.6",
-    "@storybook/client-api": "^7.0.6",
-    "@storybook/preview-web": "^7.0.6",
-    "@storybook/react": "^7.0.6",
-    "@storybook/react-vite": "7.1.0",
-    "@storybook/test-runner": "^0.11.0",
-    "@storybook/testing-library": "^0.2.0",
-    "@types/jest": "^29.5.1",
+    "@storybook-community/storybook-dark-mode": "^7.1.0",
+    "@storybook/addon-docs": "^10.1.11",
+    "@storybook/addon-links": "^10.1.11",
+    "@storybook/react-vite": "^10.1.11",
     "@types/react": "^18.0.0",
     "@types/react-dom": "^18.0.9",
-    "@types/react-test-renderer": "^18.0.0",
-    "@types/testing-library__jest-dom": "~5.14.5",
-    "@vitejs/plugin-react": "^4.0.0",
-    "assertron": "^11.0.1",
-    "cross-env": "^7.0.3",
-    "depcheck": "~1.4.3",
-    "jest": "^29.5.0",
-    "jest-watch-suspend": "^1.1.2",
-    "jest-watch-toggle-config-2": "^2.1.0",
-    "jest-watch-typeahead": "^2.2.2",
-    "npm-run-all": "^4.1.5",
+    "@vitejs/plugin-react": "^5.1.2",
+    "@vitest/browser": "^4.0.17",
+    "@vitest/browser-playwright": "^4.0.17",
+    "@vitest/coverage-v8": "^4.0.17",
+    "assertron": "^11.5.3",
+    "npm-run-all2": "^5.0.0",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
-    "repobuddy": "^1.0.1",
     "rimraf": "~5.0.0",
-    "rollup-plugin-node-externals": "^6.0.0",
     "size-limit": "~8.2.0",
-    "storybook": "7.1.0",
-    "storybook-dark-mode": "~3.0.0",
-    "ts-jest": "^29.1.0",
-    "tslib": "^2.5.0",
+    "storybook": "^10.1.11",
+    "tsdown": "^0.22.14",
     "type-plus": "^7.0.1",
     "typescript": "^5.0.4",
-    "vite": "^4.3.1",
-    "@just-web/react": "^9.0.4"
+    "vite": "^7.2.7",
+    "vitest": "^4.0.17",
+    "@just-web/react": "^9.1.1"
   },
   "peerDependencies": {
     "@just-web/react": "^9.0.0",
     "react": "^16 || ^17 || ^18"
   },
   "scripts": {
-    "build": "run-p build:cjs build:esm build:tslib",
-    "build:cjs": "buddy ts build cjs",
-    "build:esm": "tsc",
-    "build:tslib": "buddy ts build tslib",
-    "clean": "rimraf cjs esm coverage tslib --glob *.tsbuildinfo",
-    "coverage": "cross-env NODE_OPTIONS=--experimental-vm-modules NODE_NO_WARNINGS=1 jest --coverage",
-    "depcheck": "depcheck",
-    "lint": "cross-env TIMING=1 eslint --ext=ts,tsx,js,yaml,yml .",
+    "build": "tsdown",
+    "check": "biome check",
+    "clean": "rimraf coverage dist --glob *.tsbuildinfo",
+    "coverage": "vitest run --coverage",
     "nuke": "rimraf node_modules",
     "sb": "storybook dev -p 6008",
-    "size": "size-limit",
-    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
-    "test:watch": "cross-env NODE_OPTIONS=--experimental-vm-modules NODE_NO_WARNINGS=1 jest --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "w": "pnpm test:watch",
-    "verify": "npm-run-all -p build lint coverage depcheck -p size"
+    "verify": "npm-run-all -p check build coverage -p size"
   }
 }

package/src/react_intl_gizmo.tsx

@@ -0,0 +1,33 @@
+import { define, incubate } from '@just-web/app'
+import { type FormatJSGizmo, type FormatJSGizmoOptions, formatJSGizmoFn } from '@just-web/formatjs'
+import React from 'react'
+import { type IntlShape, RawIntlProvider } from 'react-intl'
+import type { ReactGizmo } from '../../react/dist/hooks/store'
+
+export type ReactIntlGizmoOptions<T = string> = FormatJSGizmoOptions<T>
+
+export const reactIntlGizmoFn = define(<T = string>(options?: ReactIntlGizmoOptions<T>) => ({
+	static: define.require<ReactGizmo>().optional<FormatJSGizmo>(),
+	async create(ctx: ReactGizmo & Partial<FormatJSGizmo>) {
+		const formatjs = await getFormatjs(ctx, options)
+		return [
+			{
+				react_intl: {
+					intl: formatjs.intl as IntlShape
+				}
+			},
+			() =>
+				ctx.react.providers.register(({ children }) => (
+					<RawIntlProvider value={formatjs.intl as IntlShape}>{children}</RawIntlProvider>
+				))
+		]
+	}
+}))
+
+export type ReactIntlGizmo = define.Infer<typeof reactIntlGizmoFn>
+
+async function getFormatjs(ctx: Partial<FormatJSGizmo>, options: ReactIntlGizmoOptions<any> | undefined) {
+	if (ctx.formatjs) return ctx.formatjs
+	if (!options) throw new Error('options is required when there is no formatjs gizmo')
+	return (await incubate().with(formatJSGizmoFn(options)).create()).formatjs
+}

package/cjs/index.d.ts

@@ -1,3 +0,0 @@
-export * from './react_intl_gizmo.js';
-export * from './react-intl.js';
-//# sourceMappingURL=index.d.ts.map

package/cjs/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA"}

package/cjs/index.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./react_intl_gizmo.js"), exports);
-__exportStar(require("./react-intl.js"), exports);
-//# sourceMappingURL=index.js.map

package/cjs/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wDAAqC;AACrC,kDAA+B"}

package/cjs/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

package/cjs/react-intl.d.ts

@@ -1,2 +0,0 @@
-export * from 'react-intl';
-//# sourceMappingURL=react-intl.d.ts.map

package/cjs/react-intl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-intl.d.ts","sourceRoot":"","sources":["../ts/react-intl.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/cjs/react-intl.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("react-intl"), exports);
-//# sourceMappingURL=react-intl.js.map

package/cjs/react-intl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-intl.js","sourceRoot":"","sources":["../ts/react-intl.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA0B"}

package/cjs/react_intl_gizmo.d.ts

@@ -1,27 +0,0 @@
-import React from 'react';
-import { define } from '@just-web/app';
-import { type FormatJSGizmoOptions } from '@just-web/formatjs';
-import { type IntlShape } from 'react-intl';
-export type ReactIntlGizmoOptions<T = string> = FormatJSGizmoOptions<T>;
-export declare const reactIntlGizmoFn: <T = string>(options?: ReactIntlGizmoOptions<T> | undefined) => import("@just-web/app").GizmoStatic<import("@just-web/app").DepBuilder<{
-    react: {
-        providers: {
-            register(Component: React.JSXElementConstructor<{
-                children: React.ReactNode;
-            }>): void;
-            values(): IterableIterator<React.JSXElementConstructor<{
-                children: React.ReactNode;
-            }>>;
-        };
-    };
-}, {
-    formatjs: {
-        intl: import("@just-web/formatjs").IntlShape<unknown>;
-    };
-}>, [{
-    react_intl: {
-        intl: IntlShape;
-    };
-}, () => void]>;
-export type ReactIntlGizmo = define.Infer<typeof reactIntlGizmoFn>;
-//# sourceMappingURL=react_intl_gizmo.d.ts.map

package/cjs/react_intl_gizmo.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react_intl_gizmo.d.ts","sourceRoot":"","sources":["../ts/react_intl_gizmo.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,EAAE,MAAM,EAAY,MAAM,eAAe,CAAA;AAChD,OAAO,EAAuC,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAEnG,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,YAAY,CAAA;AAE5D,MAAM,MAAM,qBAAqB,CAAC,CAAC,GAAG,MAAM,IAAI,oBAAoB,CAAC,CAAC,CAAC,CAAA;AAEvE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;eAkB3B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/cjs/react_intl_gizmo.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reactIntlGizmoFn = void 0;
-const react_1 = require("react");
-const app_1 = require("@just-web/app");
-const formatjs_1 = require("@just-web/formatjs");
-const react_intl_1 = require("react-intl");
-exports.reactIntlGizmoFn = (0, app_1.define)(function (options) {
-    return {
-        static: app_1.define.require().optional(),
-        async create(ctx) {
-            const formatjs = await getFormatjs(ctx, options);
-            return [
-                {
-                    react_intl: {
-                        intl: formatjs.intl
-                    }
-                },
-                () => ctx.react.providers.register(({ children }) => (react_1.default.createElement(react_intl_1.RawIntlProvider, { value: formatjs.intl }, children)))
-            ];
-        }
-    };
-});
-async function getFormatjs(ctx, options) {
-    if (ctx.formatjs)
-        return ctx.formatjs;
-    if (!options)
-        throw new Error('options is required when there is no formatjs gizmo');
-    return (await (0, app_1.incubate)().with((0, formatjs_1.formatJSGizmoFn)(options)).create()).formatjs;
-}
-//# sourceMappingURL=react_intl_gizmo.js.map

package/cjs/react_intl_gizmo.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"react_intl_gizmo.js","sourceRoot":"","sources":["../ts/react_intl_gizmo.tsx"],"names":[],"mappings":";;;AAAA,iCAAyB;AACzB,uCAAgD;AAChD,iDAAmG;AAEnG,2CAA4D;AAI/C,QAAA,gBAAgB,GAAG,IAAA,YAAM,EAAC,UAAsB,OAAkC;IAC9F,OAAO;QACN,MAAM,EAAE,YAAM,CAAC,OAAO,EAAc,CAAC,QAAQ,EAAiB;QAC9D,KAAK,CAAC,MAAM,CAAC,GAAwC;YACpD,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;YAChD,OAAO;gBACN;oBACC,UAAU,EAAE;wBACX,IAAI,EAAE,QAAQ,CAAC,IAAiB;qBAChC;iBACD;gBACD,GAAG,EAAE,CACJ,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAC9C,8BAAC,4BAAe,IAAC,KAAK,EAAE,QAAQ,CAAC,IAAiB,IAAG,QAAQ,CAAmB,CAChF,CAAC;aACH,CAAA;QACF,CAAC;KACD,CAAA;AACF,CAAC,CAAC,CAAA;AAIF,KAAK,UAAU,WAAW,CAAC,GAA2B,EAAE,OAA+C;IACtG,IAAI,GAAG,CAAC,QAAQ;QAAE,OAAO,GAAG,CAAC,QAAQ,CAAA;IACrC,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAA;IACpF,OAAO,CAAC,MAAM,IAAA,cAAQ,GAAE,CAAC,IAAI,CAAC,IAAA,0BAAe,EAAC,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAA;AAC3E,CAAC"}

package/esm/index.d.ts

@@ -1,3 +0,0 @@
-export * from './react_intl_gizmo.js';
-export * from './react-intl.js';
-//# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA"}

package/esm/index.js

@@ -1,3 +0,0 @@
-export * from './react_intl_gizmo.js';
-export * from './react-intl.js';
-//# sourceMappingURL=index.js.map

package/esm/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA"}

package/esm/react-intl.d.ts

@@ -1,2 +0,0 @@
-export * from 'react-intl';
-//# sourceMappingURL=react-intl.d.ts.map

package/esm/react-intl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-intl.d.ts","sourceRoot":"","sources":["../ts/react-intl.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/esm/react-intl.js

@@ -1,2 +0,0 @@
-export * from 'react-intl';
-//# sourceMappingURL=react-intl.js.map

package/esm/react-intl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-intl.js","sourceRoot":"","sources":["../ts/react-intl.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/esm/react_intl_gizmo.d.ts

@@ -1,27 +0,0 @@
-import React from 'react';
-import { define } from '@just-web/app';
-import { type FormatJSGizmoOptions } from '@just-web/formatjs';
-import { type IntlShape } from 'react-intl';
-export type ReactIntlGizmoOptions<T = string> = FormatJSGizmoOptions<T>;
-export declare const reactIntlGizmoFn: <T = string>(options?: ReactIntlGizmoOptions<T> | undefined) => import("@just-web/app").GizmoStatic<import("@just-web/app").DepBuilder<{
-    react: {
-        providers: {
-            register(Component: React.JSXElementConstructor<{
-                children: React.ReactNode;
-            }>): void;
-            values(): IterableIterator<React.JSXElementConstructor<{
-                children: React.ReactNode;
-            }>>;
-        };
-    };
-}, {
-    formatjs: {
-        intl: import("@just-web/formatjs").IntlShape<unknown>;
-    };
-}>, [{
-    react_intl: {
-        intl: IntlShape;
-    };
-}, () => void]>;
-export type ReactIntlGizmo = define.Infer<typeof reactIntlGizmoFn>;
-//# sourceMappingURL=react_intl_gizmo.d.ts.map

package/esm/react_intl_gizmo.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react_intl_gizmo.d.ts","sourceRoot":"","sources":["../ts/react_intl_gizmo.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,EAAE,MAAM,EAAY,MAAM,eAAe,CAAA;AAChD,OAAO,EAAuC,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAEnG,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,YAAY,CAAA;AAE5D,MAAM,MAAM,qBAAqB,CAAC,CAAC,GAAG,MAAM,IAAI,oBAAoB,CAAC,CAAC,CAAC,CAAA;AAEvE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;eAkB3B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/esm/react_intl_gizmo.js

@@ -1,28 +0,0 @@
-import React from 'react';
-import { define, incubate } from '@just-web/app';
-import { formatJSGizmoFn } from '@just-web/formatjs';
-import { RawIntlProvider } from 'react-intl';
-export const reactIntlGizmoFn = define(function (options) {
-    return {
-        static: define.require().optional(),
-        async create(ctx) {
-            const formatjs = await getFormatjs(ctx, options);
-            return [
-                {
-                    react_intl: {
-                        intl: formatjs.intl
-                    }
-                },
-                () => ctx.react.providers.register(({ children }) => (React.createElement(RawIntlProvider, { value: formatjs.intl }, children)))
-            ];
-        }
-    };
-});
-async function getFormatjs(ctx, options) {
-    if (ctx.formatjs)
-        return ctx.formatjs;
-    if (!options)
-        throw new Error('options is required when there is no formatjs gizmo');
-    return (await incubate().with(formatJSGizmoFn(options)).create()).formatjs;
-}
-//# sourceMappingURL=react_intl_gizmo.js.map

package/esm/react_intl_gizmo.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"react_intl_gizmo.js","sourceRoot":"","sources":["../ts/react_intl_gizmo.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,EAAE,eAAe,EAAiD,MAAM,oBAAoB,CAAA;AAEnG,OAAO,EAAE,eAAe,EAAkB,MAAM,YAAY,CAAA;AAI5D,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,UAAsB,OAAkC;IAC9F,OAAO;QACN,MAAM,EAAE,MAAM,CAAC,OAAO,EAAc,CAAC,QAAQ,EAAiB;QAC9D,KAAK,CAAC,MAAM,CAAC,GAAwC;YACpD,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;YAChD,OAAO;gBACN;oBACC,UAAU,EAAE;wBACX,IAAI,EAAE,QAAQ,CAAC,IAAiB;qBAChC;iBACD;gBACD,GAAG,EAAE,CACJ,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAC9C,oBAAC,eAAe,IAAC,KAAK,EAAE,QAAQ,CAAC,IAAiB,IAAG,QAAQ,CAAmB,CAChF,CAAC;aACH,CAAA;QACF,CAAC;KACD,CAAA;AACF,CAAC,CAAC,CAAA;AAIF,KAAK,UAAU,WAAW,CAAC,GAA2B,EAAE,OAA+C;IACtG,IAAI,GAAG,CAAC,QAAQ;QAAE,OAAO,GAAG,CAAC,QAAQ,CAAA;IACrC,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAA;IACpF,OAAO,CAAC,MAAM,QAAQ,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAA;AAC3E,CAAC"}

package/ts/react_intl_gizmo.tsx

@@ -1,35 +0,0 @@
-import React from 'react'
-import { define, incubate } from '@just-web/app'
-import { formatJSGizmoFn, type FormatJSGizmo, type FormatJSGizmoOptions } from '@just-web/formatjs'
-import type { ReactGizmo } from '@just-web/react'
-import { RawIntlProvider, type IntlShape } from 'react-intl'
-
-export type ReactIntlGizmoOptions<T = string> = FormatJSGizmoOptions<T>
-
-export const reactIntlGizmoFn = define(function <T = string>(options?: ReactIntlGizmoOptions<T>) {
-	return {
-		static: define.require<ReactGizmo>().optional<FormatJSGizmo>(),
-		async create(ctx: ReactGizmo & Partial<FormatJSGizmo>) {
-			const formatjs = await getFormatjs(ctx, options)
-			return [
-				{
-					react_intl: {
-						intl: formatjs.intl as IntlShape
-					}
-				},
-				() =>
-					ctx.react.providers.register(({ children }) => (
-						<RawIntlProvider value={formatjs.intl as IntlShape}>{children}</RawIntlProvider>
-					))
-			]
-		}
-	}
-})
-
-export type ReactIntlGizmo = define.Infer<typeof reactIntlGizmoFn>
-
-async function getFormatjs(ctx: Partial<FormatJSGizmo>, options: ReactIntlGizmoOptions<any> | undefined) {
-	if (ctx.formatjs) return ctx.formatjs
-	if (!options) throw new Error('options is required when there is no formatjs gizmo')
-	return (await incubate().with(formatJSGizmoFn(options)).create()).formatjs
-}