@object-ui/fields 17.3.0 → 17.6.0

package/README.md

@@ -115,20 +115,9 @@ Client-side hiding is UX only — gate authorization-sensitive values on the
 server too. See
 [`content/docs/fields/select.mdx`](../../content/docs/fields/select.mdx).
 
-<!-- release-metadata:v3.3.0 -->
-
-## Compatibility
-
-- **React:** 18.x or 19.x
-- **Node.js:** ≥ 18
-- **TypeScript:** ≥ 5.0 (strict mode)
-- **`@objectstack/spec`:** ^3.3.0
-- **`@objectstack/client`:** ^3.3.0
-- **Tailwind CSS:** ≥ 3.4 (for packages with UI)
-
 ## Links
 
-- 📚 [Documentation](https://www.objectui.org/docs/fields)
+- 📚 [Documentation](https://www.objectui.org/docs/guide/fields)
 - 📦 [npm package](https://www.npmjs.com/package/@object-ui/fields)
 - 📝 [Changelog](./CHANGELOG.md)
 - 🐛 [Report an issue](https://github.com/objectstack-ai/objectui/issues)

package/dist/FieldEditWidget.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { FieldWidgetComponentProps } from './widgets/types';
+import { FieldWidgetComponentProps } from './widgets/types.js';
 /**
  * Form field types that are deliberately NOT given an inline editor — every
  * other form widget type must be in {@link EDIT_WIDGETS}. This pairing is
@@ -10,7 +10,21 @@ import { FieldWidgetComponentProps } from './widgets/types';
 export declare const INLINE_EXCLUDED_FIELD_TYPES: Set<string>;
 /** Field types whose value is chosen in one discrete gesture (no free typing). */
 export declare const DISCRETE_EDIT_TYPES: Set<string>;
-/** True when a field type has a dedicated in-place edit widget. */
+/**
+ * True when a field type has a dedicated in-place edit widget.
+ *
+ * A RETIRED spelling answers `false` unconditionally, ahead of every table
+ * lookup (objectui#4931). This is the gate the retirement was missing: hosts
+ * ask this question to decide whether to hand a cell to {@link FieldEditWidget},
+ * and while it answered `true` for a retired spelling the whole tombstone was
+ * bypassable by delegation — the grid's inline cell editor rendered a working
+ * person picker for a field the record form refuses.
+ *
+ * Keyed on the retirement TABLE rather than on the raw `type`, and checked
+ * BEFORE `resolveInlineEditType`, so it holds even if a future retired spelling
+ * is still (or again) a key of {@link EDIT_WIDGETS} — closing the class, not
+ * one spelling.
+ */
 export declare function hasFieldEditWidget(type: string | undefined): boolean;
 /**
  * True when a field type is deliberately NOT inline-editable (alias-aware:
@@ -24,5 +38,11 @@ export declare function isInlineExcludedFieldType(type: string | undefined): boo
  * form uses — as a controlled `{ value, onChange, field }` input. Returns
  * `null` for types without a registered widget so the caller can fall back to
  * a plain editor.
+ *
+ * `autoFocus` is forwarded because an inline-edit host enters edit mode ON a
+ * field and expects the caret to land there (objectui#4220 — the detail page's
+ * delegation): each widget's own `toDomProps` whitelist already carries it onto
+ * the real focusable control, so nothing here needs to know which element that
+ * is. A host that passes nothing is unaffected.
  */
-export declare function FieldEditWidget({ field, value, onChange, readonly, }: FieldWidgetComponentProps<any>): React.ReactElement | null;
+export declare function FieldEditWidget({ field, value, onChange, readonly, autoFocus, }: FieldWidgetComponentProps<any>): React.ReactElement | null;

package/dist/currency.d.ts

@@ -11,3 +11,49 @@
  * every field/cell renderer that already depends on it.
  */
 export { resolveFieldCurrency } from '@object-ui/i18n';
+/**
+ * The number of fraction digits ISO 4217 gives `currency` — 0 for JPY/KRW/CLP,
+ * 2 for USD/EUR/CNY, 3 for KWD/BHD/OMR/TND — as ICU reports it.
+ *
+ * Returns {@link DEFAULT_FRACTION_DIGITS} when the code is not a currency code
+ * at all: `Intl` throws `RangeError: Invalid currency code` for those, and the
+ * throw must not escape, or a bad code would change the width used by the
+ * callers' own bad-currency fallbacks (objectui#4332 pinned those strings). A
+ * code that is well-formed but unknown to CLDR (e.g. `ZZZ`) does not throw —
+ * ICU answers 2 for anything outside its table, which is the same default.
+ *
+ * Memoized because the currency cell renderer runs once per grid cell: measured
+ * at 24.3us per uncached probe against 0.02us cached (200k iterations, node 22),
+ * so a 500-row grid pays ~12ms per render pass for a value that cannot change.
+ */
+export declare function currencyFractionDigits(currency: string): number;
+/**
+ * The string ICU renders in place of `currency` for a reader in `locale` — `$`
+ * for USD at `en`, `€` for EUR, U+00A5 for JPY — taken from the `currency` part
+ * of the very format the display path already uses.
+ *
+ * This is the ONE channel for the symbol (objectui#4414). It is not an
+ * independent opinion about how a currency should look: it is the same
+ * `Intl.NumberFormat(locale, { style: 'currency', currency })` that
+ * `formatDisplayNumber` formats amounts with, read one part at a time. So a
+ * widget that renders an amount in one mode and a bare symbol in another cannot
+ * disagree with itself — which is exactly what the hand-written
+ * `currency === 'USD' ? '$' : currency` ternary did, showing `JPY` beside a
+ * readonly `¥1,235`.
+ *
+ * Falls back to `currency` itself — the code as given — in the three cases
+ * where ICU cannot answer, because a bare code is a legitimate adornment (it is
+ * what ICU itself returns for KWD/BHD/CHF/ISK, and what
+ * `formatAmount`'s own bad-code branch renders beside it):
+ *
+ *  1. an invalid currency code — `Intl` throws `RangeError: Invalid currency
+ *     code`;
+ *  2. a malformed locale tag (`en_US` with an underscore, say) — `Intl` throws
+ *     `RangeError: Incorrect locale information provided`. `currencyFractionDigits`
+ *     dodged this failure mode by dropping the locale from its probe; this
+ *     helper needs the locale, so it catches instead. Neither throw may escape:
+ *     this runs during render, so an escaped `RangeError` is a blank widget.
+ *  3. no `currency` part in the output at all — not observed for
+ *     `style: 'currency'`, but coalesced rather than asserted.
+ */
+export declare function currencySymbol(currency: string, locale: string): string;

package/dist/field-type-alias.d.ts

@@ -5,12 +5,46 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
+/**
+ * The slice of a field definition the widget decision reads beyond `type`.
+ *
+ * Structural (not the spec `Field`) for the same reason the spec's own
+ * `ValueShapeFieldDef` is: every caller — object-schema metadata, a spec
+ * `FormFieldSchema` override, an action param def — can pass its own trimmed
+ * shape verbatim. `multiple` is the only key read; nothing else here is
+ * consulted, so a caller that has the whole metadata object may hand it over
+ * as-is.
+ */
+export interface FieldTypeMappingConfig {
+    /** `FieldSchema.multiple` — the field holds zero-or-more values. */
+    multiple?: boolean | null;
+}
+/**
+ * The retirement half of this module — the TOMBSTONE table
+ * {@link RETIRED_FIELD_TYPES}, the {@link isRetiredFieldType} gate, and the
+ * once-per-spelling reporter — now lives in `@object-ui/core`
+ * (`utils/retired-field-types.ts`), hoisted there by objectui#4914 so that
+ * `@object-ui/components`' filter builder can read the SAME table: `fields`
+ * depends on `components`, so the six ruled predicate faces could not all
+ * reach a table that lived here. The module's docblock carries the full
+ * reasoning, including why a second copy in `components` would have broken the
+ * ruling's "fires once" clause on day one.
+ *
+ * Re-exported from here, and from the `./index` barrel, so `@object-ui/fields`'
+ * published surface is exactly what it was plus the newly ruled gate. This file
+ * remains the retirement table's first consumer (the `field:text` tail below).
+ */
+export { RETIRED_FIELD_TYPES, isRetiredFieldType, reportRetiredFieldType, resetRetiredFieldTypeReports, } from '@object-ui/core';
 /**
  * Map field type to form component type
  *
  * @param fieldType - The ObjectQL field type identifier to convert
  * (for example: `"text"`, `"number"`, `"date"`, `"lookup"`).
+ * @param config - The rest of the field definition, for the types whose widget
+ * identity depends on more than the type string. Only `multiple` is read; see
+ * {@link MULTI_VALUE_FORM_TYPES}. Omitting it maps the single-value form, which
+ * is what every non-multi-capable type resolves to anyway.
  * @returns The normalized form field type string used in the form schema
  * (for example: `"input"`, `"textarea"`, `"date-picker"`, `"select"`).
  */
-export declare function mapFieldTypeToFormType(fieldType: string): string;
+export declare function mapFieldTypeToFormType(fieldType: string, config?: FieldTypeMappingConfig): string;