@stapel/vocabularies-react 0.1.0

package/dist/i18n/generated/errors.ru.gen.js

@@ -0,0 +1,58 @@
+/**
+ * `ru` texts for the backend error codes this catalog carries.
+ *
+ * PARTIAL, and deliberately typed to say so: 3 key(s) owned by
+ * stapel_vocabularies are absent, because that owner ships no locale catalog
+ * (ERRORS_LOCALE_EXEMPT_OWNERS). English for them still comes from the registry
+ * artifact via the en bundle; the pair layers its own authored `ru`
+ * strings over this one until upstream ships translations. `Partial` is what
+ * makes the gap visible to TypeScript instead of a silent English fallback.
+ *
+ * Import from the pair's `./i18n/ru` subpath, NOT the main entry, so
+ * the locale stays out of hosts that don't ship it.
+ */
+export const vocabulariesErrorBundleRu = {
+    "error.400.bad_request": "Некорректный запрос",
+    "error.400.captcha_invalid": "Проверка капчи не пройдена. Пожалуйста, попробуйте ещё раз.",
+    "error.400.captcha_required": "Требуется токен капчи.",
+    "error.400.expected_list": "Ожидался список элементов",
+    "error.400.field.blank": "Поле «{field}» не может быть пустым",
+    "error.400.field.does_not_exist": "«{field}» не существует",
+    "error.400.field.invalid": "Поле «{field}» содержит недопустимое значение",
+    "error.400.field.invalid_choice": "Недопустимый вариант для поля «{field}»",
+    "error.400.field.max_length": "Поле «{field}» должно содержать не более {max_length} символов",
+    "error.400.field.max_value": "Значение поля «{field}» должно быть не больше {max_value}",
+    "error.400.field.min_length": "Поле «{field}» должно содержать не менее {min_length} символов",
+    "error.400.field.min_value": "Значение поля «{field}» должно быть не меньше {min_value}",
+    "error.400.field.null": "Поле «{field}» не может быть null",
+    "error.400.field.required": "Поле «{field}» обязательно",
+    "error.400.field.unique": "Значение поля «{field}» должно быть уникальным",
+    "error.400.invalid_ad_id": "Недопустимый идентификатор объявления",
+    "error.400.validation_error": "Ошибка валидации",
+    "error.400.verification_failed": "Проверка не пройдена",
+    "error.400.verification_invalid_factor": "Этот способ подтверждения недоступен",
+    "error.401.unauthorized": "Требуется аутентификация",
+    "error.402.payment_required": "Требуется оплата",
+    "error.403.forbidden": "У вас нет прав для выполнения этого действия",
+    "error.403.network_blocked": "Запросы из этой сети не разрешены.",
+    "error.403.verification_enrollment_required": "Требуется регистрация фактора подтверждения.",
+    "error.403.verification_required": "Требуется дополнительная проверка",
+    "error.404.ad_not_found": "Объявление не найдено",
+    "error.404.not_found": "Запрошенный ресурс не найден",
+    "error.404.verification_challenge_not_found": "Запрос на подтверждение не найден или истёк",
+    "error.405.method_not_allowed": "Метод не разрешён",
+    "error.406.not_acceptable": "Недопустимый формат ответа",
+    "error.408.request_timeout": "Время ожидания запроса истекло",
+    "error.409.conflict": "Ресурс уже существует",
+    "error.410.gone": "Ресурс был безвозвратно удалён",
+    "error.413.payload_too_large": "Тело запроса слишком большое",
+    "error.415.unsupported_media_type": "Неподдерживаемый тип данных",
+    "error.422.unprocessable_entity": "Невозможно обработать данные запроса",
+    "error.423.locked": "Ресурс заблокирован",
+    "error.423.verification_locked": "Слишком много неудачных попыток — подтверждение заблокировано",
+    "error.429.rate_limit": "Слишком много попыток. Повторите попытку через {retry_after_minutes} мин.",
+    "error.429.too_many_requests": "Слишком много запросов. Пожалуйста, повторите попытку позже.",
+    "error.500.internal": "Что-то пошло не так",
+    "error.503.mandate_unavailable": "Не удалось проверить доступ к рабочему пространству",
+};
+//# sourceMappingURL=errors.ru.gen.js.map

package/dist/i18n/generated/errors.ru.gen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.ru.gen.js","sourceRoot":"","sources":["../../../src/i18n/generated/errors.ru.gen.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAmD;IACvF,uBAAuB,EAAE,qBAAqB;IAC9C,2BAA2B,EAAE,6DAA6D;IAC1F,4BAA4B,EAAE,wBAAwB;IACtD,yBAAyB,EAAE,2BAA2B;IACtD,uBAAuB,EAAE,qCAAqC;IAC9D,gCAAgC,EAAE,yBAAyB;IAC3D,yBAAyB,EAAE,+CAA+C;IAC1E,gCAAgC,EAAE,yCAAyC;IAC3E,4BAA4B,EAAE,gEAAgE;IAC9F,2BAA2B,EAAE,2DAA2D;IACxF,4BAA4B,EAAE,gEAAgE;IAC9F,2BAA2B,EAAE,2DAA2D;IACxF,sBAAsB,EAAE,mCAAmC;IAC3D,0BAA0B,EAAE,4BAA4B;IACxD,wBAAwB,EAAE,gDAAgD;IAC1E,yBAAyB,EAAE,uCAAuC;IAClE,4BAA4B,EAAE,kBAAkB;IAChD,+BAA+B,EAAE,sBAAsB;IACvD,uCAAuC,EAAE,sCAAsC;IAC/E,wBAAwB,EAAE,0BAA0B;IACpD,4BAA4B,EAAE,kBAAkB;IAChD,qBAAqB,EAAE,8CAA8C;IACrE,2BAA2B,EAAE,oCAAoC;IACjE,4CAA4C,EAAE,8CAA8C;IAC5F,iCAAiC,EAAE,mCAAmC;IACtE,wBAAwB,EAAE,uBAAuB;IACjD,qBAAqB,EAAE,8BAA8B;IACrD,4CAA4C,EAAE,6CAA6C;IAC3F,8BAA8B,EAAE,mBAAmB;IACnD,0BAA0B,EAAE,4BAA4B;IACxD,2BAA2B,EAAE,gCAAgC;IAC7D,oBAAoB,EAAE,uBAAuB;IAC7C,gBAAgB,EAAE,gCAAgC;IAClD,6BAA6B,EAAE,8BAA8B;IAC7D,kCAAkC,EAAE,6BAA6B;IACjE,gCAAgC,EAAE,sCAAsC;IACxE,kBAAkB,EAAE,qBAAqB;IACzC,+BAA+B,EAAE,+DAA+D;IAChG,sBAAsB,EAAE,2EAA2E;IACnG,6BAA6B,EAAE,8DAA8D;IAC7F,oBAAoB,EAAE,qBAAqB;IAC3C,+BAA+B,EAAE,qDAAqD;CACvF,CAAC"}

package/dist/i18n/keys.d.ts

@@ -0,0 +1,33 @@
+import type { I18nDictionary, I18nEngine } from "@stapel/core";
+/**
+ * vocabularies-react's own translation KEYS (frontend-standard §4.2): headless
+ * components never render literal strings — hosts resolve these via core's i18n
+ * engine (`useT`). Backend error codes flow through the SAME contour: a
+ * `StapelApiError.code` is already a key, so the default bundle below ships
+ * English fallbacks for both the backend error codes (generated) and the
+ * pair's own UI keys. Point core's `loadLocale` at stapel-translate to override
+ * per locale. UI keys live under the `vocabularies.` namespace.
+ */
+export declare const VOCABULARIES_I18N_KEYS: {
+    readonly unknownError: "vocabularies.error.unknown";
+    readonly termSelectPlaceholder: "vocabularies.termSelect.placeholder";
+    readonly termSelectNoMatches: "vocabularies.termSelect.noMatches";
+    readonly termSelectUnavailableTitle: "vocabularies.termSelect.unavailable.title";
+    readonly termSelectUnavailable: "vocabularies.termSelect.unavailable";
+};
+export type VocabulariesI18nKey = (typeof VOCABULARIES_I18N_KEYS)[keyof typeof VOCABULARIES_I18N_KEYS];
+/**
+ * English fallback bundle for vocabularies-react UI keys + backend error codes.
+ * The generated `vocabulariesErrorBundleEn` (from stapel-vocabularies's error registry,
+ * `pnpm gen:errors`) is spread FIRST so every backend `error.*` key has a
+ * fallback — a `StapelApiError.code` never renders as a raw key. Hand-polished
+ * copy below then OVERRIDES the generated English for the keys users see most.
+ */
+export declare const vocabulariesI18nBundleEn: I18nDictionary;
+/**
+ * Register vocabularies-react's key bundle into a core i18n engine (call once at
+ * startup). A later `loadLocale` from stapel-translate can layer localized
+ * overrides on top.
+ */
+export declare function registerVocabulariesI18n(engine: I18nEngine, locale?: string): void;
+//# sourceMappingURL=keys.d.ts.map

package/dist/i18n/keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../src/i18n/keys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG/D;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;;CAMzB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAC7B,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,OAAO,sBAAsB,CAAC,CAAC;AAEvE;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,EAAE,cAatC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,SAAO,GAAG,IAAI,CAEhF"}

package/dist/i18n/keys.js

@@ -0,0 +1,44 @@
+import { vocabulariesErrorBundleEn } from "./generated/errors.gen.js";
+/**
+ * vocabularies-react's own translation KEYS (frontend-standard §4.2): headless
+ * components never render literal strings — hosts resolve these via core's i18n
+ * engine (`useT`). Backend error codes flow through the SAME contour: a
+ * `StapelApiError.code` is already a key, so the default bundle below ships
+ * English fallbacks for both the backend error codes (generated) and the
+ * pair's own UI keys. Point core's `loadLocale` at stapel-translate to override
+ * per locale. UI keys live under the `vocabularies.` namespace.
+ */
+export const VOCABULARIES_I18N_KEYS = {
+    unknownError: "vocabularies.error.unknown",
+    termSelectPlaceholder: "vocabularies.termSelect.placeholder",
+    termSelectNoMatches: "vocabularies.termSelect.noMatches",
+    termSelectUnavailableTitle: "vocabularies.termSelect.unavailable.title",
+    termSelectUnavailable: "vocabularies.termSelect.unavailable",
+};
+/**
+ * English fallback bundle for vocabularies-react UI keys + backend error codes.
+ * The generated `vocabulariesErrorBundleEn` (from stapel-vocabularies's error registry,
+ * `pnpm gen:errors`) is spread FIRST so every backend `error.*` key has a
+ * fallback — a `StapelApiError.code` never renders as a raw key. Hand-polished
+ * copy below then OVERRIDES the generated English for the keys users see most.
+ */
+export const vocabulariesI18nBundleEn = {
+    // Backend error codes — generated en fallbacks (coverage by construction).
+    ...vocabulariesErrorBundleEn,
+    // vocabularies-react UI
+    "vocabularies.error.unknown": "Something went wrong. Please try again.",
+    // the default skin's own copy (see i18n/ru.ts, i18n/es.ts)
+    "vocabularies.termSelect.placeholder": "Start typing to search…",
+    "vocabularies.termSelect.noMatches": "No term matches that.",
+    "vocabularies.termSelect.unavailable.title": "This list cannot be loaded",
+    "vocabularies.termSelect.unavailable": "The terms for this field come from a vocabulary service that is not configured here, so there is nothing to choose from. Nobody can answer this question until it is wired up — please report it.",
+};
+/**
+ * Register vocabularies-react's key bundle into a core i18n engine (call once at
+ * startup). A later `loadLocale` from stapel-translate can layer localized
+ * overrides on top.
+ */
+export function registerVocabulariesI18n(engine, locale = "en") {
+    engine.registerBundle(locale, vocabulariesI18nBundleEn);
+}
+//# sourceMappingURL=keys.js.map

package/dist/i18n/keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.js","sourceRoot":"","sources":["../../src/i18n/keys.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAEtE;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,YAAY,EAAE,4BAA4B;IAC1C,qBAAqB,EAAE,qCAAqC;IAC5D,mBAAmB,EAAE,mCAAmC;IACxD,0BAA0B,EAAE,2CAA2C;IACvE,qBAAqB,EAAE,qCAAqC;CACpD,CAAC;AAKX;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAmB;IACtD,2EAA2E;IAC3E,GAAG,yBAAyB;IAE5B,wBAAwB;IACxB,4BAA4B,EAAE,yCAAyC;IAEvE,2DAA2D;IAC3D,qCAAqC,EAAE,yBAAyB;IAChE,mCAAmC,EAAE,uBAAuB;IAC5D,2CAA2C,EAAE,4BAA4B;IACzE,qCAAqC,EACnC,mMAAmM;CACtM,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CAAC,MAAkB,EAAE,MAAM,GAAG,IAAI;IACxE,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;AAC1D,CAAC"}

package/dist/i18n/ru.d.ts

@@ -0,0 +1,26 @@
+import type { I18nDictionary, I18nEngine } from "@stapel/core";
+export { vocabulariesErrorBundleRu } from "./generated/errors.ru.gen.js";
+/**
+ * Russian bundle for vocabularies-react — shipped as the
+ * `@stapel/vocabularies-react/i18n/ru` subpath (i18n-shipping.md §2) so the locale is
+ * opt-in: a host that never registers it never carries these strings (the main
+ * entry does not import this module).
+ *
+ * TWO SOURCES, ON PURPOSE. The generated `vocabulariesErrorBundleRu` covers the
+ * 42 cross-cutting codes stapel-core owns and localizes. The 3 codes
+ * stapel-vocabularies owns are NOT in it and cannot be: the module ships no
+ * `translations/` directory at all, so the generator emits a `Partial` bundle
+ * and says so in its own header (`ERRORS_LOCALE_EXEMPT_OWNERS`, the
+ * stapel-geo / stapel-reviews precedent). They are authored below, beside the
+ * UI copy. When upstream ships `translations/errors.ru.json`, those three
+ * lines are deleted and the generated bundle covers them — the keys and the
+ * texts do not move.
+ */
+export declare const vocabulariesI18nBundleRu: I18nDictionary;
+/**
+ * Register the Russian bundle. The en bundle goes UNDER it
+ * (merge-priority convention): a key this locale has not translated yet
+ * degrades to ENGLISH, never to a raw key.
+ */
+export declare function registerVocabulariesI18nRu(engine: I18nEngine, locale?: string): void;
+//# sourceMappingURL=ru.d.ts.map

package/dist/i18n/ru.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ru.d.ts","sourceRoot":"","sources":["../../src/i18n/ru.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAI/D,OAAO,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AAEzE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB,EAAE,cAkBtC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,UAAU,EAClB,MAAM,SAAO,GACZ,IAAI,CAGN"}

package/dist/i18n/ru.js

@@ -0,0 +1,43 @@
+import { vocabulariesErrorBundleRu } from "./generated/errors.ru.gen.js";
+import { vocabulariesI18nBundleEn } from "./keys.js";
+export { vocabulariesErrorBundleRu } from "./generated/errors.ru.gen.js";
+/**
+ * Russian bundle for vocabularies-react — shipped as the
+ * `@stapel/vocabularies-react/i18n/ru` subpath (i18n-shipping.md §2) so the locale is
+ * opt-in: a host that never registers it never carries these strings (the main
+ * entry does not import this module).
+ *
+ * TWO SOURCES, ON PURPOSE. The generated `vocabulariesErrorBundleRu` covers the
+ * 42 cross-cutting codes stapel-core owns and localizes. The 3 codes
+ * stapel-vocabularies owns are NOT in it and cannot be: the module ships no
+ * `translations/` directory at all, so the generator emits a `Partial` bundle
+ * and says so in its own header (`ERRORS_LOCALE_EXEMPT_OWNERS`, the
+ * stapel-geo / stapel-reviews precedent). They are authored below, beside the
+ * UI copy. When upstream ships `translations/errors.ru.json`, those three
+ * lines are deleted and the generated bundle covers them — the keys and the
+ * texts do not move.
+ */
+export const vocabulariesI18nBundleRu = {
+    // Backend error codes — generated ru texts for every key core owns.
+    ...vocabulariesErrorBundleRu,
+    // Backend error codes stapel-vocabularies owns — authored here (see above).
+    "error.400.vocabularies_bad_parent": "На родительском уровне «{level}» нет термина «{parent}»",
+    "error.404.vocabularies_level_not_found": "В справочнике «{vocabulary}» нет уровня «{level}»",
+    "error.404.vocabularies_vocabulary_not_found": "Справочник не найден",
+    // vocabularies-react UI
+    "vocabularies.error.unknown": "Что-то пошло не так. Попробуйте ещё раз.",
+    "vocabularies.termSelect.placeholder": "Начните вводить для поиска…",
+    "vocabularies.termSelect.noMatches": "Ничего не найдено.",
+    "vocabularies.termSelect.unavailable.title": "Список не удалось загрузить",
+    "vocabularies.termSelect.unavailable": "Значения для этого поля берутся из справочника, который здесь не подключён, и выбирать не из чего. Ответить на этот вопрос невозможно — сообщите, пожалуйста, об этом.",
+};
+/**
+ * Register the Russian bundle. The en bundle goes UNDER it
+ * (merge-priority convention): a key this locale has not translated yet
+ * degrades to ENGLISH, never to a raw key.
+ */
+export function registerVocabulariesI18nRu(engine, locale = "ru") {
+    engine.registerBundle(locale, vocabulariesI18nBundleEn);
+    engine.registerBundle(locale, vocabulariesI18nBundleRu);
+}
+//# sourceMappingURL=ru.js.map

package/dist/i18n/ru.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ru.js","sourceRoot":"","sources":["../../src/i18n/ru.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAErD,OAAO,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AAEzE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAmB;IACtD,oEAAoE;IACpE,GAAG,yBAAyB;IAE5B,4EAA4E;IAC5E,mCAAmC,EACjC,yDAAyD;IAC3D,wCAAwC,EACtC,mDAAmD;IACrD,6CAA6C,EAAE,sBAAsB;IAErE,wBAAwB;IACxB,4BAA4B,EAAE,0CAA0C;IACxE,qCAAqC,EAAE,6BAA6B;IACpE,mCAAmC,EAAE,oBAAoB;IACzD,2CAA2C,EAAE,6BAA6B;IAC1E,qCAAqC,EACnC,wKAAwK;CAC3K,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,0BAA0B,CACxC,MAAkB,EAClB,MAAM,GAAG,IAAI;IAEb,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;IACxD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;AAC1D,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `@stapel/vocabularies-react` — the headless React flow pair for stapel-vocabularies
+ * (frontend-standard §2). Business + state only, zero visual opinion. Built on
+ * `@stapel/core`'s StapelClient (verification-403 interception, token refresh,
+ * i18n, analytics, query layer).
+ *
+ * Scaffolded by `stapel-new-react-lib`. Layers: api → model → flows → headless
+ * → i18n. Generated surfaces (flows registry, error map, manifest, llms.txt)
+ * are produced by the monorepo `gen:*` drivers and stand under drift gates.
+ */
+export { createVocabulariesApi } from "./api/vocabulariesApi.js";
+export type { VocabulariesApi } from "./api/vocabulariesApi.js";
+export type { Schemas, Vocabulary, Level, Term, TermPage } from "./api/types.js";
+export { createVocabularyClient, DEFAULT_TERM_LIMIT, RESOLVE_BATCH, } from "./client.js";
+export type { VocabularyClient, VocabularyTerm, CreateVocabularyClientOptions, } from "./client.js";
+export { createFlowMachine, useFlow, isErrorCode } from "@stapel/core";
+export type { FlowMachine, FlowMachineOptions, FlowStateBase, FlowError, } from "@stapel/core";
+export { toFlowError } from "./flows/errors.js";
+export { VOCABULARIES_FLOWS, flowEndpoints } from "./flows/registry.js";
+export type { VocabulariesFlowId, VocabulariesFlowSpec, FlowEndpoint, } from "./flows/registry.js";
+export { createVocabulariesRuntime } from "./model/runtime.js";
+export type { VocabulariesRuntime, CreateVocabulariesRuntimeOptions, } from "./model/runtime.js";
+export { VocabulariesRuntimeContext, useVocabulariesRuntime, useVocabulariesApi, useVocabulariesAnalytics, } from "./model/context.js";
+export { vocabulariesQueryKeys } from "./model/queryKeys.js";
+export { useTermSearch, TERM_SEARCH_DEBOUNCE_MS } from "./model/useTermSearch.js";
+export type { TermSearchOptions, TermSearchState } from "./model/useTermSearch.js";
+export { useTermLabels, termLabel } from "./model/useTermLabels.js";
+export type { TermLabels, TermLabelsOptions } from "./model/useTermLabels.js";
+export { VocabulariesProvider } from "./headless/VocabulariesProvider.js";
+export { VOCABULARIES_I18N_KEYS, vocabulariesI18nBundleEn, registerVocabulariesI18n, } from "./i18n/keys.js";
+export type { VocabulariesI18nKey } from "./i18n/keys.js";
+export { VOCABULARIES_ERRORS, VOCABULARIES_ERROR_CODES, vocabulariesErrorBundleEn, explainVocabulariesError, } from "./i18n/errorsMap.js";
+export type { VocabulariesErrorCode, VocabulariesErrorSpec, Remediation, } from "./i18n/errorsMap.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,YAAY,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAQjF,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,aAAa,GACd,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,gBAAgB,EAChB,cAAc,EACd,6BAA6B,GAC9B,MAAM,aAAa,CAAC;AAKrB,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AACvE,YAAY,EACV,WAAW,EACX,kBAAkB,EAClB,aAAa,EACb,SAAS,GACV,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACxE,YAAY,EACV,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,GACb,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,YAAY,EACV,mBAAmB,EACnB,gCAAgC,GACjC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,0BAA0B,EAC1B,sBAAsB,EACtB,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAClF,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACnF,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACpE,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAG9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAG1E,OAAO,EACL,sBAAsB,EACtB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAG1D,OAAO,EACL,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,EACzB,wBAAwB,GACzB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,qBAAqB,EACrB,qBAAqB,EACrB,WAAW,GACZ,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,38 @@
+/**
+ * `@stapel/vocabularies-react` — the headless React flow pair for stapel-vocabularies
+ * (frontend-standard §2). Business + state only, zero visual opinion. Built on
+ * `@stapel/core`'s StapelClient (verification-403 interception, token refresh,
+ * i18n, analytics, query layer).
+ *
+ * Scaffolded by `stapel-new-react-lib`. Layers: api → model → flows → headless
+ * → i18n. Generated surfaces (flows registry, error map, manifest, llms.txt)
+ * are produced by the monorepo `gen:*` drivers and stand under drift gates.
+ */
+// ── api ──────────────────────────────────────────────────────────────────────
+export { createVocabulariesApi } from "./api/vocabulariesApi.js";
+// ── the seam (attributes-v2 §3.4) ────────────────────────────────────────────
+// `createVocabularyClient` returns the two functions
+// `@stapel/attributes-react` declares as `VocabularyClient` and hands to
+// `<VocabularyClientProvider>`. The shape is satisfied STRUCTURALLY: neither
+// package imports the other (test/clientShape.test.ts is the proof), so the
+// two L2 pairs stay independently releasable.
+export { createVocabularyClient, DEFAULT_TERM_LIMIT, RESOLVE_BATCH, } from "./client.js";
+// ── flows ────────────────────────────────────────────────────────────────────
+// The flow-machine primitive lives in `@stapel/core` (one reviewed copy for
+// every pair — frontend-core-architecture §4b). Re-exported for ergonomics.
+export { createFlowMachine, useFlow, isErrorCode } from "@stapel/core";
+export { toFlowError } from "./flows/errors.js";
+export { VOCABULARIES_FLOWS, flowEndpoints } from "./flows/registry.js";
+// ── model (runtime wiring, query keys, context) ──────────────────────────────
+export { createVocabulariesRuntime } from "./model/runtime.js";
+export { VocabulariesRuntimeContext, useVocabulariesRuntime, useVocabulariesApi, useVocabulariesAnalytics, } from "./model/context.js";
+export { vocabulariesQueryKeys } from "./model/queryKeys.js";
+export { useTermSearch, TERM_SEARCH_DEBOUNCE_MS } from "./model/useTermSearch.js";
+export { useTermLabels, termLabel } from "./model/useTermLabels.js";
+// ── headless (renderless components) ─────────────────────────────────────────
+export { VocabulariesProvider } from "./headless/VocabulariesProvider.js";
+// ── i18n ─────────────────────────────────────────────────────────────────────
+export { VOCABULARIES_I18N_KEYS, vocabulariesI18nBundleEn, registerVocabulariesI18n, } from "./i18n/keys.js";
+// ── errors map (code → status/params/remediation/en; generated) ──────────────
+export { VOCABULARIES_ERRORS, VOCABULARIES_ERROR_CODES, vocabulariesErrorBundleEn, explainVocabulariesError, } from "./i18n/errorsMap.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,gFAAgF;AAChF,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAIjE,gFAAgF;AAChF,qDAAqD;AACrD,yEAAyE;AACzE,6EAA6E;AAC7E,4EAA4E;AAC5E,8CAA8C;AAC9C,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,aAAa,GACd,MAAM,aAAa,CAAC;AAOrB,gFAAgF;AAChF,4EAA4E;AAC5E,4EAA4E;AAC5E,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAOvE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAOxE,gFAAgF;AAChF,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAK/D,OAAO,EACL,0BAA0B,EAC1B,sBAAsB,EACtB,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAElF,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAGpE,gFAAgF;AAChF,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE1E,gFAAgF;AAChF,OAAO,EACL,sBAAsB,EACtB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,gBAAgB,CAAC;AAGxB,gFAAgF;AAChF,OAAO,EACL,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,EACzB,wBAAwB,GACzB,MAAM,qBAAqB,CAAC"}

package/dist/model/context.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from "react";
+import type { Analytics, ModuleContextKit } from "@stapel/core";
+import type { VocabulariesApi } from "../api/vocabulariesApi.js";
+import type { VocabulariesRuntime } from "./runtime.js";
+export declare const VocabulariesRuntimeContext: Context<VocabulariesRuntime | null>;
+export declare const useVocabulariesRuntime: () => VocabulariesRuntime;
+export declare const useVocabulariesApi: () => VocabulariesApi;
+export declare const useVocabulariesAnalytics: () => Analytics | null;
+/** @internal Re-exported as `<VocabulariesProvider>` from `headless/`. */
+export declare const ModuleProvider: ModuleContextKit<VocabulariesRuntime>["Provider"];
+//# sourceMappingURL=context.d.ts.map

package/dist/model/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/model/context.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAErC,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAYxD,eAAO,MAAM,0BAA0B,EAAE,OAAO,CAAC,mBAAmB,GAAG,IAAI,CACvD,CAAC;AAErB,eAAO,MAAM,sBAAsB,EAAE,MAAM,mBAAoC,CAAC;AAEhF,eAAO,MAAM,kBAAkB,EAAE,MAAM,eAA4B,CAAC;AAEpE,eAAO,MAAM,wBAAwB,EAAE,MAAM,SAAS,GAAG,IAAuB,CAAC;AAEjF,0EAA0E;AAC1E,eAAO,MAAM,cAAc,EAAE,gBAAgB,CAAC,mBAAmB,CAAC,CAAC,UAAU,CAC/D,CAAC"}

package/dist/model/context.js

@@ -0,0 +1,16 @@
+import { createModuleContext } from "@stapel/core";
+/**
+ * The wired VocabulariesRuntime shared through React context by
+ * `<VocabulariesProvider>`. Hooks in `model/` and `headless/` read the singletons
+ * from here. One reviewed copy of this plumbing lives in `@stapel/core`
+ * (`createModuleContext`, slim wave §21/S2); this module binds it under the
+ * pair's public names.
+ */
+const kit = createModuleContext("Vocabularies");
+export const VocabulariesRuntimeContext = kit.RuntimeContext;
+export const useVocabulariesRuntime = kit.useRuntime;
+export const useVocabulariesApi = kit.useApi;
+export const useVocabulariesAnalytics = kit.useAnalytics;
+/** @internal Re-exported as `<VocabulariesProvider>` from `headless/`. */
+export const ModuleProvider = kit.Provider;
+//# sourceMappingURL=context.js.map

package/dist/model/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../src/model/context.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAKnD;;;;;;GAMG;AACH,MAAM,GAAG,GACP,mBAAmB,CAAsB,cAAc,CAAC,CAAC;AAE3D,MAAM,CAAC,MAAM,0BAA0B,GACrC,GAAG,CAAC,cAAc,CAAC;AAErB,MAAM,CAAC,MAAM,sBAAsB,GAA8B,GAAG,CAAC,UAAU,CAAC;AAEhF,MAAM,CAAC,MAAM,kBAAkB,GAA0B,GAAG,CAAC,MAAM,CAAC;AAEpE,MAAM,CAAC,MAAM,wBAAwB,GAA2B,GAAG,CAAC,YAAY,CAAC;AAEjF,0EAA0E;AAC1E,MAAM,CAAC,MAAM,cAAc,GACzB,GAAG,CAAC,QAAQ,CAAC"}

package/dist/model/queryKeys.d.ts

@@ -0,0 +1,5 @@
+export declare const vocabulariesQueryKeys: {
+    readonly all: readonly ["vocabularies"];
+    termLabels: (vocabulary: string, level: string, codes: readonly string[]) => readonly ["vocabularies", "termLabels", string, string, string];
+};
+//# sourceMappingURL=queryKeys.d.ts.map

package/dist/model/queryKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryKeys.d.ts","sourceRoot":"","sources":["../../src/model/queryKeys.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,qBAAqB,EAAE;IAClC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;IACxC,UAAU,EAAE,CACV,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,SAAS,MAAM,EAAE,KACrB,SAAS,CAAC,cAAc,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAatE,CAAC"}

package/dist/model/queryKeys.js

@@ -0,0 +1,28 @@
+/**
+ * Namespaced TanStack Query keys (frontend-standard §2 — "keys are namespaced").
+ * Everything under the `"vocabularies"` root so a host can invalidate the whole
+ * module or match a single resource. Explicit tuple return types satisfy
+ * `--isolatedDeclarations`.
+ *
+ * Only ONE read is keyed here, and that is not an oversight: a term SEARCH is
+ * not a cacheable resource — it is superseded per keystroke and its answer is
+ * scoped to a dropdown that is about to close — so `useTermSearch` owns its own
+ * in-flight state and never enters the cache. `useTermLabels` is the opposite:
+ * a stable `{code: label}` for codes a page already holds, worth caching across
+ * every control that shows the same term, which is why it is a query.
+ */
+const ROOT = "vocabularies";
+export const vocabulariesQueryKeys = {
+    all: [ROOT],
+    // The codes are sorted and joined into ONE key segment: two controls asking
+    // for the same set in a different order are the same read, and an array
+    // segment would make them two cache entries and two round trips.
+    termLabels: (vocabulary, level, codes) => [
+        ROOT,
+        "termLabels",
+        vocabulary,
+        level,
+        [...codes].sort().join(","),
+    ],
+};
+//# sourceMappingURL=queryKeys.js.map

package/dist/model/queryKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryKeys.js","sourceRoot":"","sources":["../../src/model/queryKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,IAAI,GAAG,cAAuB,CAAC;AAErC,MAAM,CAAC,MAAM,qBAAqB,GAO9B;IACF,GAAG,EAAE,CAAC,IAAI,CAAC;IACX,4EAA4E;IAC5E,wEAAwE;IACxE,iEAAiE;IACjE,UAAU,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC;QACxC,IAAI;QACJ,YAAY;QACZ,UAAU;QACV,KAAK;QACL,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;KAC5B;CACF,CAAC"}

package/dist/model/runtime.d.ts

@@ -0,0 +1,17 @@
+import type { CreateModuleRuntimeOptions, ModuleRuntime } from "@stapel/core";
+import type { VocabulariesApi } from "../api/vocabulariesApi.js";
+/**
+ * The wired vocabularies runtime — core's `ModuleRuntime` bound to this pair's
+ * API (slim wave §21/S2: the plumbing lives once in `@stapel/core`'s
+ * `createModuleRuntime`/`createModuleContext`; this module only binds the
+ * module-prefixed names). The returned `client` is what the host injects
+ * into core's `StapelConfigProvider` (as the default or the `"vocabularies"`
+ * module client), preserving the client-injection fork seam
+ * (frontend-standard §7.2). Auth token/refresh and the verification-403 seam
+ * are supplied by the host's auth runtime on the shared client — this pair
+ * does not re-implement them.
+ */
+export type VocabulariesRuntime = ModuleRuntime<VocabulariesApi>;
+export type CreateVocabulariesRuntimeOptions = CreateModuleRuntimeOptions;
+export declare function createVocabulariesRuntime(options: CreateVocabulariesRuntimeOptions): VocabulariesRuntime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/model/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/model/runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAEjE;;;;;;;;;;GAUG;AACH,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,eAAe,CAAC,CAAC;AAEjE,MAAM,MAAM,gCAAgC,GAAG,0BAA0B,CAAC;AAE1E,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,gCAAgC,GACxC,mBAAmB,CAErB"}

package/dist/model/runtime.js

@@ -0,0 +1,6 @@
+import { createModuleRuntime } from "@stapel/core";
+import { createVocabulariesApi } from "../api/vocabulariesApi.js";
+export function createVocabulariesRuntime(options) {
+    return createModuleRuntime(createVocabulariesApi, options);
+}
+//# sourceMappingURL=runtime.js.map

package/dist/model/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../src/model/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAkBlE,MAAM,UAAU,yBAAyB,CACvC,OAAyC;IAEzC,OAAO,mBAAmB,CAAC,qBAAqB,EAAE,OAAO,CAAC,CAAC;AAC7D,CAAC"}

package/dist/model/useTermLabels.d.ts

@@ -0,0 +1,26 @@
+import type { LoadState } from "@stapel/core";
+import type { VocabularyClient } from "../client.js";
+export interface TermLabelsOptions {
+    readonly vocabulary: string;
+    readonly level: string;
+    readonly codes: readonly string[];
+}
+export type TermLabels = Readonly<Record<string, string>>;
+/**
+ * Labels for `codes`, as a load state. Disabled — and therefore `loading`,
+ * never `ready` with an empty map — while there is no client, no pointer or
+ * nothing to resolve.
+ */
+export declare function useTermLabels(client: VocabularyClient | null, options: TermLabelsOptions): LoadState<TermLabels>;
+/**
+ * The one right way to READ that state for display: a resolved label, or the
+ * code itself while the answer is in flight, when the load failed, or when the
+ * server omitted the code because it does not know it.
+ *
+ * All four fall back the same way ON PURPOSE — the code is what the person's
+ * answer literally is, so showing it is never wrong, only less kind. A control
+ * that needs to distinguish them (an admin screen auditing dead codes) reads
+ * the {@link LoadState} directly.
+ */
+export declare function termLabel(labels: LoadState<TermLabels>, code: string): string;
+//# sourceMappingURL=useTermLabels.d.ts.map

package/dist/model/useTermLabels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTermLabels.d.ts","sourceRoot":"","sources":["../../src/model/useTermLabels.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGrD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAE1D;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,gBAAgB,GAAG,IAAI,EAC/B,OAAO,EAAE,iBAAiB,GACzB,SAAS,CAAC,UAAU,CAAC,CAevB;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,UAAU,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7E"}

package/dist/model/useTermLabels.js

@@ -0,0 +1,58 @@
+/**
+ * `useTermLabels` — `{code: label}` for codes a page already HOLDS.
+ *
+ * The other half of the seam. A stored answer on a listing is a list of term
+ * CODES (`["apple", "iphone-15-pro"]`); the labels are not stored with it,
+ * because a label is translated and a code is not. So a reopened draft, a
+ * filter chip, a facet row — anything showing an answer somebody already gave
+ * — has to ask for the words.
+ *
+ * Unlike a search this IS a cacheable resource: the same codes give the same
+ * labels until the vocabulary's revision moves, and several controls on one
+ * page routinely ask for the same set. So it is a TanStack query keyed through
+ * the factory, and the answer is a {@link LoadState} rather than a bare map —
+ * `{}` would say "these codes have no labels" in exactly the same words as
+ * "nobody has asked yet" and "the request failed" (core `loadState.ts`).
+ *
+ * The fallback a caller wants is almost always the CODE ITSELF, which is what
+ * {@link termLabel} does: the stored answer is the truth, and a blank control
+ * is a worse lie than a slug.
+ */
+import { useQuery } from "@tanstack/react-query";
+import { loadStateFromQuery } from "@stapel/core";
+import { vocabulariesQueryKeys } from "./queryKeys.js";
+/**
+ * Labels for `codes`, as a load state. Disabled — and therefore `loading`,
+ * never `ready` with an empty map — while there is no client, no pointer or
+ * nothing to resolve.
+ */
+export function useTermLabels(client, options) {
+    const { vocabulary, level, codes } = options;
+    const wanted = codes.filter((code) => code.length > 0);
+    const enabled = client !== null && vocabulary.length > 0 && level.length > 0 && wanted.length > 0;
+    const query = useQuery({
+        queryKey: vocabulariesQueryKeys.termLabels(vocabulary, level, wanted),
+        enabled,
+        queryFn: async () => {
+            // `enabled` already guarantees this, and the compiler does not know it.
+            if (client === null)
+                return {};
+            return await client.resolve(vocabulary, level, wanted);
+        },
+    });
+    return loadStateFromQuery(query);
+}
+/**
+ * The one right way to READ that state for display: a resolved label, or the
+ * code itself while the answer is in flight, when the load failed, or when the
+ * server omitted the code because it does not know it.
+ *
+ * All four fall back the same way ON PURPOSE — the code is what the person's
+ * answer literally is, so showing it is never wrong, only less kind. A control
+ * that needs to distinguish them (an admin screen auditing dead codes) reads
+ * the {@link LoadState} directly.
+ */
+export function termLabel(labels, code) {
+    return labels.status === "ready" ? (labels.data[code] ?? code) : code;
+}
+//# sourceMappingURL=useTermLabels.js.map

package/dist/model/useTermLabels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTermLabels.js","sourceRoot":"","sources":["../../src/model/useTermLabels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAGlD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAUvD;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAC3B,MAA+B,EAC/B,OAA0B;IAE1B,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC;IAC7C,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvD,MAAM,OAAO,GACX,MAAM,KAAK,IAAI,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;IACpF,MAAM,KAAK,GAAG,QAAQ,CAAC;QACrB,QAAQ,EAAE,qBAAqB,CAAC,UAAU,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,CAAC;QACrE,OAAO;QACP,OAAO,EAAE,KAAK,IAAyB,EAAE;YACvC,wEAAwE;YACxE,IAAI,MAAM,KAAK,IAAI;gBAAE,OAAO,EAAE,CAAC;YAC/B,OAAO,MAAM,MAAM,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;QACzD,CAAC;KACF,CAAC,CAAC;IACH,OAAO,kBAAkB,CAAC,KAAK,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,SAAS,CAAC,MAA6B,EAAE,IAAY;IACnE,OAAO,MAAM,CAAC,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACxE,CAAC"}

package/dist/model/useTermSearch.d.ts

@@ -0,0 +1,24 @@
+import type { VocabularyClient, VocabularyTerm } from "../client.js";
+/** The pause after the last keystroke before a query goes to the server. Long
+ * enough that typing a word is one request, short enough that it still feels
+ * like the control answered. Mirrors the ref editors in attributes-react. */
+export declare const TERM_SEARCH_DEBOUNCE_MS = 250;
+export interface TermSearchOptions {
+    readonly vocabulary: string;
+    readonly level: string;
+    /** Code of a term at the level above; narrows the page to its children.
+     * `undefined` means the whole level. */
+    readonly parent?: string | undefined;
+    readonly debounceMs?: number;
+}
+export interface TermSearchState {
+    readonly terms: readonly VocabularyTerm[];
+    readonly loading: boolean;
+    /** A person typed. Debounced and superseding. */
+    search: (query: string) => void;
+    /** A dropdown opened. Fetches the first page immediately, once per
+     * (vocabulary, level, parent). */
+    open: () => void;
+}
+export declare function useTermSearch(client: VocabularyClient | null, options: TermSearchOptions): TermSearchState;
+//# sourceMappingURL=useTermSearch.d.ts.map

package/dist/model/useTermSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTermSearch.d.ts","sourceRoot":"","sources":["../../src/model/useTermSearch.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAErE;;6EAE6E;AAC7E,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;4CACwC;IACxC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,iDAAiD;IACjD,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC;sCACkC;IAClC,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,gBAAgB,GAAG,IAAI,EAC/B,OAAO,EAAE,iBAAiB,GACzB,eAAe,CA8DjB"}