@bottlebooks/valid-values 2.0.1 → 3.0.0

package/src/validValues/designation.ts

@@ -1,134 +1,103 @@
-import type { MessageDescriptor } from '@lingui/core';
 import { defineMessage } from '@lingui/macro';
-import type { ProductType as ProductTypeKey } from './types/ProductTypeKey.js';
+import { ValidValueDefinition } from './types/ValidValueDefinition.js';
 
-// I copied the original definition here because the one in the /types folder has diverged and doesn't follow the original idea.
-// I'd rather recommend keeping this a simple baseline than putting any possible option into it.
-interface ValidValueDefinition {
-  title: MessageDescriptor;
-  /**
-   * Fields that will never be stored in the database,
-   * because they are not relevant to the frontend rendering.
-   * They are only used for the form, like grouping values for easier entry.
-   */
-  form?: {
-    /**
-     * A helpful description shown only when using the form.
-     */
-    description?: MessageDescriptor;
-  };
-  /**
-   * Fields that are stored in the database together with each lookup value,
-   * because they affect the frontend rendering.
-   * They are also included in the hash values to detect breaking changes.
-   *
-   * We should try to avoid them if possible because if false positives:
-   * Any change in one of those fields would lead to
-   * eLabels that are marked as incompatible,
-   * although there might be no user-visible changes.
-   */
-  frontend?: {};
-}
-
-interface DesignationInput extends ValidValueDefinition {}
+interface Designation extends ValidValueDefinition {}
 
-/** Adds the key to the designation and makes sure we can only add valid designations. */
-const designation = <Key extends string>(
-  key: Key,
-  value: DesignationInput
-) => ({
-  ...value,
-  key,
-});
+/** Makes sure errors are displayed where the error is introduced. */
+const designation = (value: Designation) => value;
 
-const allDesignations = [
-  designation('brut', {
-    title: defineMessage({
+const allDesignations = {
+  brut: designation({
+    key: 'brut',
+    label: defineMessage({
       id: 'validValues.designation.brut',
       message: 'brut',
     }),
   }),
-  designation('brut_nature', {
-    title: defineMessage({
+  brut_nature: designation({
+    key: 'brut_nature',
+    label: defineMessage({
       id: 'validValues.designation.brut_nature',
       message: 'brut nature',
     }),
   }),
-  designation('demi-sec', {
-    title: defineMessage({
+  'demi-sec': designation({
+    key: 'demi-sec',
+    label: defineMessage({
       id: 'validValues.designation.demi-sec',
       message: 'demi-sec',
     }),
   }),
-  designation('dry', {
-    title: defineMessage({
+  dry: designation({
+    key: 'dry',
+    label: defineMessage({
       id: 'validValues.designation.dry',
       message: 'dry',
     }),
   }),
-  designation('extra_brut', {
-    title: defineMessage({
+  extra_brut: designation({
+    key: 'extra_brut',
+    label: defineMessage({
       id: 'validValues.designation.extra_brut',
       message: 'extra brut',
     }),
   }),
-  designation('extra_dry', {
-    title: defineMessage({
+  extra_dry: designation({
+    key: 'extra_dry',
+    label: defineMessage({
       id: 'validValues.designation.extra_dry',
       message: 'extra dry',
     }),
   }),
-  designation('feinherb', {
-    title: defineMessage({
+  feinherb: designation({
+    key: 'feinherb',
+    label: defineMessage({
       id: 'validValues.designation.feinherb',
       message: 'feinherb',
     }),
   }),
-  designation('lieblich', {
-    title: defineMessage({
+  lieblich: designation({
+    key: 'lieblich',
+    label: defineMessage({
       id: 'validValues.designation.lieblich',
       message: 'lieblich',
     }),
   }),
-  designation('semi', {
-    title: defineMessage({
+  semi: designation({
+    key: 'semi',
+    label: defineMessage({
       id: 'validValues.designation.semi',
       message: 'semi-dry',
     }),
   }),
-  designation('sweet', {
-    title: defineMessage({
+  sweet: designation({
+    key: 'sweet',
+    label: defineMessage({
       id: 'validValues.designation.sweet',
       message: 'sweet/dessert',
     }),
   }),
-  designation('semi_sweet', {
-    title: defineMessage({
+  semi_sweet: designation({
+    key: 'semi_sweet',
+    label: defineMessage({
       id: 'validValues.designation.semi_sweet',
       message: 'semi-sweet',
     }),
   }),
-] as const;
-
-type DesignationKey = typeof allDesignations[number]['key'];
-interface DesignationOutput extends DesignationInput {
-  key: DesignationKey;
-}
+} as const;
 
-const allDesignationsByKey = Object.fromEntries(
-  allDesignations.map((designation) => [designation.key, designation])
-) as Record<DesignationKey, DesignationOutput>;
+export type DesignationKey = keyof typeof allDesignations;
 
 /** Makes sure we are only able to use valid keys. */
 function pick<Key extends DesignationKey>(keys: Key[]) {
   return Object.fromEntries(
-    keys.map((key) => [key, allDesignationsByKey[key]])
-  ) as Record<Key, DesignationOutput>;
+    keys.map((key) => [key, allDesignations[key]])
+  ) as Record<Key, Designation>;
 }
 
 // TODO Enforce/provide Autocomplete for product types here.
 // I think this will only be possible with the `satisfies` keyword coming in TS 4.9.
-const byProductType = {
+export const byProductType = {
   beer: {},
   spirit_absinthe: {},
   spirit_anise: {},
@@ -177,16 +146,4 @@ const byProductType = {
   wine_aromatized: pick(['extra_dry', 'dry', 'semi', 'semi_sweet', 'sweet']),
 };
 
-const listByProductType = Object.fromEntries(
-  (Object.keys(byProductType) as ProductTypeKey[]).map((type) => [
-    type,
-    Object.values(byProductType[type]),
-  ])
-) as Record<ProductTypeKey, DesignationOutput[]>;
-
-export default {
-  byProductType,
-  listByProductType,
-  list: allDesignations,
-  byId: allDesignationsByKey,
-};
+export default allDesignations;