@bottlebooks/valid-values 1.1.0

package/src/validValues/designation.ts

@@ -0,0 +1,198 @@
+import type { MessageDescriptor } from '@lingui/core';
+import { defineMessage } from '@lingui/macro';
+import type { ProductType as ProductTypeKey } from './types/ProductTypeKey.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 {
+  /**
+   * The translatable title of the valid value.
+   *
+   * Define it using `defineMessage()` from @lingui/macro.
+   */
+  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 {}
+
+/** 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,
+});
+
+const allDesignations = [
+  designation('brut', {
+    title: defineMessage({
+      id: 'validValues.designation.brut',
+      message: 'brut',
+    }),
+  }),
+  designation('brut_nature', {
+    title: defineMessage({
+      id: 'validValues.designation.brut_nature',
+      message: 'brut nature',
+    }),
+  }),
+  designation('demi-sec', {
+    title: defineMessage({
+      id: 'validValues.designation.demi-sec',
+      message: 'demi-sec',
+    }),
+  }),
+  designation('dry', {
+    title: defineMessage({
+      id: 'validValues.designation.dry',
+      message: 'dry',
+    }),
+  }),
+  designation('extra_brut', {
+    title: defineMessage({
+      id: 'validValues.designation.extra_brut',
+      message: 'extra brut',
+    }),
+  }),
+  designation('extra_dry', {
+    title: defineMessage({
+      id: 'validValues.designation.extra_dry',
+      message: 'extra dry',
+    }),
+  }),
+  designation('feinherb', {
+    title: defineMessage({
+      id: 'validValues.designation.feinherb',
+      message: 'feinherb',
+    }),
+  }),
+  designation('lieblich', {
+    title: defineMessage({
+      id: 'validValues.designation.lieblich',
+      message: 'lieblich',
+    }),
+  }),
+  designation('semi', {
+    title: defineMessage({
+      id: 'validValues.designation.semi',
+      message: 'semi-dry',
+    }),
+  }),
+  designation('sweet', {
+    title: defineMessage({
+      id: 'validValues.designation.sweet',
+      message: 'sweet/dessert',
+    }),
+  }),
+  designation('semi_sweet', {
+    title: defineMessage({
+      id: 'validValues.designation.semi_sweet',
+      message: 'semi-sweet',
+    }),
+  }),
+] as const;
+
+type DesignationKey = typeof allDesignations[number]['key'];
+interface DesignationOutput extends DesignationInput {
+  key: DesignationKey;
+}
+
+const allDesignationsByKey = Object.fromEntries(
+  allDesignations.map((designation) => [designation.key, designation])
+) as Record<DesignationKey, DesignationOutput>;
+
+/** 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>;
+}
+
+// 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 = {
+  beer: {},
+  spirit_absinthe: {},
+  spirit_anise: {},
+  spirit_aquavit: {},
+  spirit_arak: {},
+  spirit_armagnac: {},
+  spirit_asianspirit: {},
+  spirit_bitter: {},
+  spirit_cachaca: {},
+  spirit_calvados: {},
+  spirit_cocktail: {},
+  spirit_cognac: {},
+  spirit_fruitspirit: {},
+  spirit_genever: {},
+  spirit_gin: {},
+  spirit_grainspirit: {},
+  spirit_grapebrandy: {},
+  spirit_grappa: {},
+  spirit_liqueur: {},
+  spirit_marc: {},
+  spirit_mezcal: {},
+  spirit_miscspririt: {},
+  spirit_ouzo: {},
+  spirit_pastis: {},
+  spirit_pisco: {},
+  spirit_raki: {},
+  spirit_rum: {},
+  spirit_sambuca: {},
+  spirit_shochu: {},
+  spirit_schnaps: {},
+  spirit_tequila: {},
+  spirit_vermouth: {},
+  spirit_vodka: {},
+  spirit_whisky: {},
+  spirit_whiskey: {},
+  wine_fortified: pick(['dry', 'semi', 'sweet']),
+  wine_pearlwine: pick(['dry', 'semi', 'sweet']),
+  wine_sparkling: pick([
+    'brut_nature',
+    'extra_brut',
+    'brut',
+    'extra_dry',
+    'dry',
+    'demi-sec',
+  ]),
+  wine_stillwine: pick(['dry', 'feinherb', 'lieblich', 'semi', 'sweet']),
+  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,
+};