@box/metadata-template-editor 1.19.0

package/dist/esm/lib/components/metadata-field-configurator/components/type-specific-configuration/taxonomy/taxonomy-selector.js

@@ -0,0 +1,103 @@
+import { Button as n, Popover as s, LoadingIndicator as w, Text as h, TextInput as L } from "@box/blueprint-web";
+import { Plus as P } from "@box/blueprint-web-assets/icons/Fill";
+import { useState as x } from "react";
+import { useIntl as O } from "react-intl";
+import { useTaxonomyOptions as N } from "../../../context/taxonomy-options-context.js";
+import o from "./taxonomy-selector-messages.js";
+import { jsx as a, jsxs as l, Fragment as k } from "react/jsx-runtime";
+import '../../../../../../../styles/taxonomy-selector.css';const z = "_taxonomySelectorLabel_b3aww_1", j = "_listWrapper_b3aww_14", M = "_listWrapperWithPadding_b3aww_19", $ = "_taxonomyItem_b3aww_24", q = "_statusContainer_b3aww_30", r = {
+  taxonomySelectorLabel: z,
+  listWrapper: j,
+  listWrapperWithPadding: M,
+  taxonomyItem: $,
+  statusContainer: q
+}, G = ({
+  data: g,
+  onClick: u,
+  onSearchValue: i,
+  triggerButton: y,
+  disabled: b,
+  resetValueOnHide: f
+}) => {
+  const {
+    formatMessage: t
+  } = O(), {
+    status: c,
+    onSelectorOpen: d
+  } = N(), [C, m] = x(""), [_, p] = x(!1), v = (e) => {
+    m(e), i(e);
+  }, I = (e) => {
+    p(e), e && d(), !e && f && (m(""), i(""));
+  }, S = (e) => {
+    u(e), p(!1);
+  }, W = y ?? /* @__PURE__ */ a(n, {
+    variant: "secondary",
+    size: "large",
+    endIcon: P,
+    "aria-label": t(o.taxonomySelectorAriaLabel),
+    children: t(o.taxonomySelector)
+  }), T = () => c === "loading" ? /* @__PURE__ */ a("div", {
+    className: r.statusContainer,
+    children: /* @__PURE__ */ a(w, {
+      "aria-label": t(o.loadingTaxonomies)
+    })
+  }) : c === "error" ? /* @__PURE__ */ l("div", {
+    className: r.statusContainer,
+    children: [/* @__PURE__ */ a(h, {
+      as: "p",
+      variant: "bodyDefault",
+      color: "textOnLightSecondary",
+      children: t(o.loadTaxonomiesError)
+    }), /* @__PURE__ */ a(n, {
+      variant: "secondary",
+      size: "small",
+      onClick: d,
+      children: t(o.retryLoadTaxonomies)
+    })]
+  }) : /* @__PURE__ */ l(k, {
+    children: [/* @__PURE__ */ a("div", {
+      className: `${r.listWrapper} ${r.listWrapperWithPadding}`,
+      children: /* @__PURE__ */ a(L, {
+        label: t(o.searchTaxonomiesInputPlaceholder),
+        placeholder: t(o.searchTaxonomiesInputPlaceholder),
+        value: C,
+        onChange: (e) => v(e.target.value),
+        hideLabel: !0,
+        "aria-label": t(o.searchTaxonomiesInputPlaceholder)
+      })
+    }), /* @__PURE__ */ a(h, {
+      as: "span",
+      variant: "caption",
+      color: "textOnLightSecondary",
+      className: r.taxonomySelectorLabel,
+      children: t(o.allTaxonomies)
+    }), /* @__PURE__ */ a("div", {
+      className: r.listWrapper,
+      children: g.map((e) => /* @__PURE__ */ a(n, {
+        type: "button",
+        variant: "quaternary",
+        size: "large",
+        disabled: e?.levels?.length === 0,
+        onClick: () => S(e),
+        className: r.taxonomyItem,
+        children: e.label
+      }, e.id))
+    })]
+  });
+  return /* @__PURE__ */ l(s.Root, {
+    modal: !1,
+    open: _,
+    onOpenChange: I,
+    children: [/* @__PURE__ */ a(s.Trigger, {
+      disabled: b,
+      children: W
+    }), /* @__PURE__ */ a(s.ContentContainer, {
+      align: "start",
+      "aria-label": t(o.taxonomySelector),
+      children: T()
+    })]
+  });
+};
+export {
+  G as TaxonomySelector
+};

package/dist/esm/lib/components/metadata-field-configurator/components/type-specific-configuration/taxonomy/useTaxonomySelect.js

@@ -0,0 +1,19 @@
+import { taxonomyDefaultValues as s } from "./taxonomy-default-values.js";
+const m = (o) => ({
+  onTaxonomySelect: (l) => {
+    const e = o.values.taxonomy.availableTaxonomies.find((a) => a.id === l.id);
+    o.setFieldValue("taxonomy", {
+      ...s.taxonomy,
+      availableTaxonomies: o.values.taxonomy.availableTaxonomies.map((a) => ({
+        ...a,
+        selected: a.id === l.id
+      })),
+      selectedLevels: e?.levels[0] ? [e.levels[0].level] : [],
+      taxonomyKey: e?.taxonomyKey ?? "",
+      namespace: e?.namespace ?? ""
+    });
+  }
+});
+export {
+  m as useTaxonomySelect
+};

package/dist/esm/lib/components/metadata-field-configurator/components/type-specific-configuration/taxonomy/utils.js

@@ -0,0 +1,4 @@
+const t = (e, o) => e.filter((l) => l.label.toLowerCase().includes(o.toLowerCase()));
+export {
+  t as filterTaxonomiesByValue
+};

package/dist/esm/lib/components/metadata-field-configurator/context/field-configurator-context.js

@@ -0,0 +1,68 @@
+import c from "lodash/cloneDeep";
+import i from "lodash/set";
+import { createContext as P, useContext as j, useState as l, useCallback as n, useMemo as k } from "react";
+import { jsx as y } from "react/jsx-runtime";
+const V = /* @__PURE__ */ P(null);
+function q() {
+  const s = j(V);
+  if (!s)
+    throw new Error("useFieldConfigurator must be used within a FieldConfiguratorContext provider");
+  return s;
+}
+const z = ({
+  initialValues: s,
+  initialErrors: w = {},
+  initialTouched: S = {},
+  children: T
+}) => {
+  const [d, u] = l(s), [m] = l(w), [f, a] = l(S), x = n((t, e) => {
+    u((o) => ({
+      ...o,
+      [t]: e
+    }));
+  }, []), C = n((t) => u(t), []), g = n((t, e = !0) => {
+    a((o) => {
+      const r = c(o);
+      return i(r, t, e), r;
+    });
+  }, []), h = n((t) => a(t), []), F = n((t) => {
+    const {
+      name: e,
+      value: o
+    } = t.target;
+    u((r) => {
+      const v = c(r);
+      return i(v, e, o), v;
+    });
+  }, []), p = n((t) => {
+    const e = t.target;
+    e.name && a((o) => {
+      const r = c(o);
+      return i(r, e.name, !0), r;
+    });
+  }, []), b = k(() => ({
+    values: d,
+    errors: m,
+    touched: f,
+    isValid: !0,
+    setFieldValue: x,
+    setValues: C,
+    setFieldTouched: g,
+    setTouched: h,
+    handleChange: F,
+    handleBlur: p,
+    // No-op: FieldConfiguratorProvider has no validation layer.
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    validateForm: async () => {
+    }
+  }), [d, m, f, x, C, g, h, F, p]);
+  return /* @__PURE__ */ y(V.Provider, {
+    value: b,
+    children: T
+  });
+};
+export {
+  V as FieldConfiguratorContext,
+  z as FieldConfiguratorProvider,
+  q as useFieldConfigurator
+};

package/dist/esm/lib/components/metadata-field-configurator/context/field-extensions-context.js

@@ -0,0 +1,9 @@
+import { createContext as t, useContext as e } from "react";
+const n = /* @__PURE__ */ t([]);
+function s() {
+  return e(n);
+}
+export {
+  n as FieldExtensionsContext,
+  s as useFieldExtensions
+};

package/dist/esm/lib/components/metadata-field-configurator/context/taxonomy-options-context.js

@@ -0,0 +1,23 @@
+import { createContext as o, useContext as n } from "react";
+const e = {
+  options: [],
+  status: "success",
+  onSelectorOpen: () => {
+  }
+}, s = /* @__PURE__ */ o(e);
+function r() {
+  return n(s);
+}
+function u(t) {
+  return {
+    options: t,
+    status: "success",
+    onSelectorOpen: () => {
+    }
+  };
+}
+export {
+  s as TaxonomyOptionsContext,
+  u as createStaticTaxonomyContext,
+  r as useTaxonomyOptions
+};

package/dist/esm/lib/components/metadata-field-configurator/hooks/useFieldConfiguratorBehavior.js

@@ -0,0 +1,119 @@
+import { useState as I, useCallback as n, useMemo as w, useRef as x, useEffect as f } from "react";
+import { useIntl as oe } from "react-intl";
+import re from "lodash/cloneDeep";
+import ce from "lodash/set";
+import { FieldTypeIcon as de } from "../../../utils/field-options/field-type-icon.js";
+import { useFieldExtensions as se } from "../context/field-extensions-context.js";
+import { general as le } from "../messages/configurator-messages.js";
+import { createDefaultFieldValues as fe, hasVisibleErrors as me } from "../utils.js";
+import { useFieldValidation as pe } from "./useFieldValidation.js";
+import { useTaxonomyFetch as ae } from "./useTaxonomyFetch.js";
+function Re({
+  values: e,
+  onValuesChange: i,
+  onDelete: T,
+  isExpanded: m,
+  onExpandedChange: V,
+  submitAttemptCount: d,
+  taxonomyOptions: C,
+  fetchTaxonomies: S,
+  fieldExtensionsProp: B,
+  onValidationChange: N
+}) {
+  const u = oe(), {
+    errors: p,
+    touched: a,
+    isValid: s,
+    validateForm: M,
+    touchAll: R,
+    setFieldTouched: P,
+    setTouched: q,
+    handleBlur: H
+  } = pe(e), K = ae(S, C), j = se(), b = B ?? j, [z, A] = I(() => e.isFieldNew === !0), [G, F] = I(!1), [h, O] = I("edit"), o = m !== void 0 ? m : z, J = !e.isFieldReadOnly && e.isFieldNew, r = e.id, L = `field-name-${r}`, Q = `field-description-${r}`, l = n((t, c) => {
+    i({
+      ...e,
+      [t]: c
+    });
+  }, [e, i]), k = n((t) => {
+    const {
+      name: c,
+      value: ne
+    } = t.target, D = re(e);
+    ce(D, c, ne), i(D);
+  }, [e, i]), U = w(
+    () => ({
+      values: e,
+      errors: p,
+      touched: a,
+      isValid: s,
+      setFieldValue: l,
+      setValues: i,
+      setFieldTouched: P,
+      setTouched: q,
+      handleChange: k,
+      handleBlur: H,
+      validateForm: M
+    }),
+    // setFieldTouched, setTouched, handleBlur are stable (no deps).
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e, p, a, s, l, i, k, M]
+  ), E = x(o);
+  f(() => {
+    const t = E.current;
+    E.current = o, t && !o && (R(), O("edit"));
+  }, [o]);
+  const W = x(d);
+  f(() => {
+    !d || d === W.current || R();
+  }, [d]);
+  const $ = x(N);
+  $.current = N, f(() => {
+    $.current?.(s);
+  }, [s]), f(() => {
+    e.isFieldNew && (m !== void 0 ? V?.(!0) : A(!0));
+  }, [e.isFieldNew]);
+  const X = n((t) => l("hidden", t), [l]), y = n(() => {
+    T?.(e.key), F(!1);
+  }, [T, e.key]), Y = n(() => {
+    e.isFieldNew ? y() : F(!0);
+  }, [y, e.isFieldNew]), Z = n(() => F(!1), []), _ = n((t) => A(t === r), [r]), v = n((t) => {
+    i({
+      ...fe(t),
+      key: e.key,
+      hidden: e.hidden,
+      isFieldNew: e.isFieldNew,
+      isFieldReadOnly: e.isFieldReadOnly,
+      name: e.name,
+      description: e.description
+    });
+  }, [i, e]), ee = w(() => {
+    const t = e.name || u.formatMessage(le.fieldNameInputPlaceholder), c = e.type === "dropdown" ? ` (${e.dropdown?.options?.length ?? 0})` : "";
+    return `${t}${c}`;
+  }, [e.name, e.type, e.dropdown?.options?.length, u]), te = w(() => de(e.type), [e.type]), g = h === "edit" ? 0 : Number(h.replace("ext-", "")) + 1, ie = g > 0 ? b[g - 1] ?? null : null;
+  return {
+    contextValue: U,
+    taxonomyContextValue: K,
+    extensions: b,
+    isActive: o,
+    handleAccordionValueChange: _,
+    isDeleteConfirmationModalOpen: G,
+    openConfirmationModal: Y,
+    closeConfirmationModal: Z,
+    handleDeleteField: y,
+    activeTabId: h,
+    setActiveTabId: O,
+    activeExtension: ie,
+    isTypeEditable: J,
+    uniqueKey: r,
+    nameInputId: L,
+    descriptionInputId: Q,
+    accordionTitle: ee,
+    TitleIcon: te,
+    hasErrors: me(p, a),
+    handleTypeChange: v,
+    handleChangeVisibility: X
+  };
+}
+export {
+  Re as useFieldConfiguratorBehavior
+};

package/dist/esm/lib/components/metadata-field-configurator/hooks/useFieldValidation.js

@@ -0,0 +1,68 @@
+import { useState as d, useCallback as n, useEffect as h, useRef as S } from "react";
+import * as b from "yup";
+import f from "lodash/set";
+import y from "lodash/cloneDeep";
+import { useTemplateFieldSchema as k } from "./useTemplateFieldSchema.js";
+import { markAllTouched as w } from "../utils.js";
+function A(t) {
+  const c = {};
+  return (t.inner.length > 0 ? t.inner : [t]).forEach((a) => {
+    a.path && f(c, a.path, a.message);
+  }), c;
+}
+function Y(t) {
+  const c = k(), [a, m] = d({}), [T, u] = d(!1), [E, s] = d({}), l = n(async (e, r) => {
+    try {
+      if (await c.validate(e, {
+        abortEarly: !1
+      }), r?.cancelled)
+        return;
+      m({}), u(!0);
+    } catch (o) {
+      if (r?.cancelled)
+        return;
+      o instanceof b.ValidationError && (m(A(o)), u(!1));
+    }
+  }, [c]);
+  h(() => {
+    const e = {
+      cancelled: !1
+    };
+    return l(t, e), () => {
+      e.cancelled = !0;
+    };
+  }, [t, l]);
+  const p = S(t.type);
+  h(() => {
+    p.current !== t.type && (p.current = t.type, s(({
+      dropdown: e,
+      taxonomy: r,
+      ...o
+    }) => o));
+  }, [t.type]);
+  const g = n(() => l(t), [l, t]), x = n(() => s(w(t)), [t]), F = n((e, r = !0) => {
+    s((o) => {
+      const i = y(o);
+      return f(i, e, r), i;
+    });
+  }, []), V = n((e) => s(e), []), R = n((e) => {
+    const r = e.target;
+    r.name && s((o) => {
+      const i = y(o);
+      return f(i, r.name, !0), i;
+    });
+  }, []);
+  return {
+    errors: a,
+    touched: E,
+    isValid: T,
+    validateForm: g,
+    touchAll: x,
+    setFieldTouched: F,
+    setTouched: V,
+    handleBlur: R
+  };
+}
+export {
+  Y as useFieldValidation
+};

package/dist/esm/lib/components/metadata-field-configurator/hooks/useTaxonomyFetch.js

@@ -0,0 +1,27 @@
+import { useState as c, useRef as p, useCallback as o } from "react";
+import { createStaticTaxonomyContext as y } from "../context/taxonomy-options-context.js";
+function g(t, u = []) {
+  const [e, r] = c("idle"), [a, i] = c([]), n = p(!1), s = o(async () => {
+    if (!(!t || n.current)) {
+      n.current = !0, r("loading");
+      try {
+        const f = await t();
+        i(f), r("success");
+      } catch {
+        r("error");
+      } finally {
+        n.current = !1;
+      }
+    }
+  }, [t]), l = o(() => {
+    e === "success" || e === "loading" || s();
+  }, [s, e]);
+  return t ? {
+    options: a,
+    status: e,
+    onSelectorOpen: l
+  } : y(u);
+}
+export {
+  g as useTaxonomyFetch
+};

package/dist/esm/lib/components/metadata-field-configurator/hooks/useTemplateFieldSchema.js

@@ -0,0 +1,44 @@
+import { useMemo as y } from "react";
+import { useIntl as h } from "react-intl";
+import * as e from "yup";
+import { T as b, F as i } from "../../../../../chunks/types.js";
+import { METADATA_TEMPLATE_FIELD_NAME_MAX_LENGTH as q } from "../../../utils/constants.js";
+import { validationErrors as n } from "../messages/configurator-messages.js";
+const j = () => {
+  const t = h();
+  return y(() => {
+    const m = e.string().min(1).max(q, t.formatMessage(n.fieldNameTooLong)).required(t.formatMessage(n.fieldNameCannotBeEmpty)).test("no-whitespace-only", t.formatMessage(n.fieldNameCannotBeEmpty), (o) => !o || o.trim().length > 0), c = e.object().shape({
+      key: e.string().required(t.formatMessage(n.optionKeyCannotBeEmpty)).test("unique-key", t.formatMessage(n.duplicateOption), (o, r) => {
+        if (!o)
+          return !0;
+        const l = r?.from?.[0]?.value, s = r?.from?.[1].value?.options ?? [], u = s.findIndex((a) => a.id === l?.id);
+        return !s.some((a, f) => f !== u && a.key === o);
+      })
+    }), p = e.object().shape({
+      dropdown: e.object().shape({
+        allowMultipleSelections: e.boolean().required(),
+        options: e.array().of(c).min(1).required()
+      })
+    }), d = e.object().shape({
+      taxonomy: e.object().shape({
+        namespace: e.string().required(),
+        taxonomyKey: e.string().required(),
+        allowMultipleSelections: e.boolean().required(),
+        selection: e.mixed().oneOf(Object.values(b)).required(),
+        selectedLevels: e.array().of(e.number().required()).min(1).required()
+      })
+    });
+    return e.lazy((o) => {
+      const r = e.object().shape({
+        type: e.mixed().oneOf(Object.values(i)).required(),
+        name: m,
+        description: e.string().nullable(),
+        hidden: e.boolean().required()
+      });
+      return o?.type === i.Dropdown ? r.concat(p) : o?.type === i.Taxonomy ? r.concat(d) : r;
+    });
+  }, [t]);
+};
+export {
+  j as useTemplateFieldSchema
+};

package/dist/esm/lib/components/metadata-field-configurator/index.js

@@ -0,0 +1,11 @@
+import { useTemplateFieldSchema as o } from "./hooks/useTemplateFieldSchema.js";
+import { MetadataFieldConfigurator as a } from "./metadata-field-configurator.js";
+import { createDefaultFieldValues as l } from "./utils.js";
+import { FieldExtensionsContext as x, useFieldExtensions as d } from "./context/field-extensions-context.js";
+export {
+  x as FieldExtensionsContext,
+  a as MetadataFieldConfigurator,
+  l as createDefaultFieldValues,
+  d as useFieldExtensions,
+  o as useTemplateFieldSchema
+};

package/dist/esm/lib/components/metadata-field-configurator/messages/configurator-messages.js

@@ -0,0 +1,136 @@
+import { defineMessages as e } from "react-intl";
+const t = e({
+  fieldTypeLabel: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.fieldTypeLabel",
+    defaultMessage: "Field Type"
+  },
+  fieldTypePlaceholder: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.fieldTypePlaceholder",
+    defaultMessage: "Select Type"
+  },
+  fieldNameLabel: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.fieldNameLabel",
+    defaultMessage: "Field Name"
+  },
+  fieldNameInputPlaceholder: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.fieldNameInputPlaceholder",
+    defaultMessage: "Add a field name/label"
+  },
+  fieldDescriptionLabel: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.fieldDescriptionLabel",
+    defaultMessage: "Field Description"
+  },
+  fieldDescriptionInputPlaceholder: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.fieldDescriptionInputPlaceholder",
+    defaultMessage: "Add custom help text that appears in a tooltip for users"
+  },
+  descriptionInfoTooltip: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.descriptionInfoTooltip",
+    defaultMessage: "The description is visible to anyone accessing the template. It also helps Box AI find and autofill Metadata for you."
+  },
+  descriptionLearnMoreBadgeAriaLabel: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.descriptionLearnMoreBadgeAriaLabel",
+    defaultMessage: "Learn more about the description field"
+  },
+  dragAndDropFieldAriaLabel: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.dragAndDropFieldAriaLabel",
+    defaultMessage: "Drag and drop to reorder field"
+  },
+  hideField: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.hideField",
+    defaultMessage: "Hide Field"
+  },
+  showField: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.showField",
+    defaultMessage: "Make Visible"
+  },
+  hiddenStatus: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.hiddenStatus",
+    defaultMessage: "Hidden"
+  },
+  deleteFieldTitle: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.deleteFieldTitle",
+    defaultMessage: 'Delete "{fieldName}" Field'
+  },
+  deleteFieldDescription: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.deleteFieldDescription",
+    defaultMessage: "All files or folders associated with this field will now have an unassigned value. This action cannot be undone once the template is saved."
+  },
+  cancelDeleteField: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.cancelDeleteField",
+    defaultMessage: "Cancel"
+  },
+  confirmDeleteField: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.confirmDeleteField",
+    defaultMessage: "Confirm"
+  },
+  moveUp: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.moveUp",
+    defaultMessage: "Move Up"
+  },
+  moveUpAriaLabel: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.moveUpAriaLabel",
+    defaultMessage: "Move field up"
+  },
+  moveDown: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.moveDown",
+    defaultMessage: "Move Down"
+  },
+  moveDownAriaLabel: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.moveDownAriaLabel",
+    defaultMessage: "Move field down"
+  },
+  deleteField: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.deleteField",
+    defaultMessage: "Remove"
+  },
+  deleteFieldAriaLabel: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.deleteFieldAriaLabel",
+    defaultMessage: "Delete field"
+  },
+  contextMenuAriaLabel: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.contextMenuAriaLabel",
+    defaultMessage: "Field configurator context menu"
+  },
+  editTabAriaLabel: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.editTabAriaLabel",
+    defaultMessage: "Edit field"
+  },
+  duplicateField: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.duplicateField",
+    defaultMessage: "Duplicate"
+  },
+  duplicateFieldAriaLabel: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.duplicateFieldAriaLabel",
+    defaultMessage: "Duplicate field"
+  }
+}), d = e({
+  fieldNameCannotBeEmpty: {
+    id: "groupSharedFeatures.metadataTemplateEditor.fields.validationErrors.fieldNameCannotBeEmpty",
+    defaultMessage: "Field name cannot be empty."
+  },
+  fieldNameTooLong: {
+    id: "groupSharedFeatures.metadataTemplateEditor.fields.validationErrors.fieldNameTooLong",
+    defaultMessage: "The field name is too long."
+  },
+  duplicateOption: {
+    id: "groupSharedFeatures.metadataTemplateEditor.fields.validationErrors.duplicateOption",
+    defaultMessage: "The option label must be unique."
+  },
+  optionKeyCannotBeEmpty: {
+    id: "groupSharedFeatures.metadataTemplateEditor.fields.validationErrors.optionKeyCannotBeEmpty",
+    defaultMessage: "Option cannot be empty."
+  },
+  selectedLevelRequired: {
+    id: "groupSharedFeatures.metadataTemplateEditor.fields.validationErrors.selectedLevelRequired",
+    defaultMessage: "Please select a level."
+  },
+  thisFieldContainsErrors: {
+    id: "groupSharedFeatures.metadataTemplateEditor.templates.details.fields.thisFieldContainsErrors",
+    defaultMessage: "This field contains validation errors."
+  }
+});
+export {
+  t as general,
+  d as validationErrors
+};

package/dist/esm/lib/components/metadata-field-configurator/messages/dropdown-messages.js

@@ -0,0 +1,38 @@
+import { defineMessages as e } from "react-intl";
+const o = e({
+  addOption: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.dropdown.addOption",
+    defaultMessage: "+ Add Option"
+  },
+  deleteDropdownOptionAriaLabel: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.dropdown.deleteDropdownOptionAriaLabel",
+    defaultMessage: "Delete option"
+  },
+  dragAndDropOptionAriaLabel: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.dropdown.dragAndDropOptionAriaLabel",
+    defaultMessage: "Drag and drop to reorder option"
+  },
+  allowMultipleSelection: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.dropdown.allowMultipleSelection",
+    defaultMessage: "Allow Multiple Selections"
+  },
+  addAnOptionOptionPlaceholder: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.dropdown.addAnOptionOptionPlaceholder",
+    defaultMessage: "Add an option"
+  },
+  deleteOptionTitle: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.dropdown.deleteOptionTitle",
+    defaultMessage: 'Delete "{optionName}" Option'
+  },
+  deleteOptionDescription: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.dropdown.deleteOptionDescription",
+    defaultMessage: "All files or folders associated with this will now have an unassigned value. This action cannot be undone once the template is saved."
+  },
+  optionListValidationError: {
+    id: "groupSharedFeatures.metadataTemplateEditor.configurator.dropdown.optionListValidationError",
+    defaultMessage: "Some options in this list contain validation errors."
+  }
+});
+export {
+  o as default
+};