@bottlebooks/valid-values 1.1.0

package/src/main.ts

@@ -0,0 +1,44 @@
+import createValidValues from './validValues/utils/createValidValues.js';
+import './style.css';
+import * as validValues from './validValues.js';
+
+document.querySelector<HTMLDivElement>('#app')!.innerHTML = `
+  <div>
+    <h1>ValidValues</h1>
+    ${Object.entries(validValues)
+      .map(([key, values]) => {
+        if (values.list) {
+          const list = values.list as ReturnType<
+            typeof createValidValues
+          >['list'];
+          return `<h2>${key}</h2>
+            <pre>${list().map((item, i) =>
+              i === 0
+                ? JSON.stringify(
+                    {
+                      // @ts-ignore
+                      id: item.id,
+                      'title(en)': item.getTitle('en'),
+                      'title(de)': item.getTitle('de'),
+                      titles: item.getTitles(['de', 'en', 'es', 'fr']),
+                      ...item,
+                      form: item.form && {
+                        ...item.form,
+                        // 'description(en)': item.form?.getDescription('en'),
+                        // 'description(de)': item.form?.getDescription('de'),
+                      },
+                    },
+                    undefined,
+                    2
+                  )
+                : ''
+            )}</pre>
+          `;
+        }
+        return `<h2>${key}</h2>
+          <pre>${JSON.stringify(values, undefined, 2)}</pre>
+        `;
+      })
+      .join('')}</pre></code>
+  </div>
+`;

package/src/scripts/README.md

@@ -0,0 +1,6 @@
+Steps for transformis legacy server side valid values
+1. run writeFields.not.test.js
+2. for every valid value category copy ```validValues/json/$category.json``` itno ```validValus/$category.ts```
+2.1. Search ```title: \{(.*?(.|[\n])*?)\}``` and replace with ```title: defineMessage({$1})```
+2.2. Search ```description: \{(.*?(.|[\n])*?)\}``` and replace with ```description: defineMessage({$1})```
+3. Generated files created under /locales/json can be copied into qr-app/src/assets/i18n-ext

package/src/scripts/transformArchitectureVV.js

@@ -0,0 +1,143 @@
+// const { sortBy } = require('lodash');
+const mappings = require('../../../../bottlebooks-server/architecture/validvalues/mappings');
+
+const all = {
+  // awards: {
+  //   _json: require('../../../../bottlebooks-server/architecture/validvalues/validvalues/awards.json'),
+  //   _mapping: { medals: mappings['awards-awardsMedals'] },
+  //   props: { addForm: false },
+  // },
+  // awardsMedals: {
+  //   _json: require('../../../../bottlebooks-server/architecture/validvalues/validvalues/awardsMedals.json'),
+  //   props: { addForm: false },
+  // },
+  // wineColor: {
+  //   _json: require('../../../../bottlebooks-server/architecture/validvalues/validvalues/wineColor.json'),
+  //   props: { addForm: false },
+  // },
+  // wineType: {
+  //   _json: require('../../../../bottlebooks-server/architecture/validvalues/validvalues/wineType.json'),
+  //   props: { addForm: false },
+  // },
+  // designation: require('../../../../bottlebooks-server/architecture/validvalues/validvalues/designation.json'),
+  // country: {
+  //   _json: require('../../../../bottlebooks-server/architecture/validvalues/validvalues/country.json'),
+  //   _mapping: { regions: mappings['country-appelation'] },
+  //   props: { addForm: false },
+  // },
+  // region: {
+  //   _json: require('../../../../bottlebooks-server/architecture/validvalues/validvalues/appelation'),
+  //   _mapping: { subregions: mappings['appelation-subregion'] },
+  //   props: { addForm: true },
+  // },
+  // subregion: {
+  //   _json: require('../../../../bottlebooks-server/architecture/validvalues/validvalues/subregion'),
+  //   props: { addForm: true },
+  // },
+  // beerStyle: {
+  //   _json: require('../../../../bottlebooks-server/architecture/validvalues/validvalues/beerStyle.json'),
+  //   props: { addForm: false },
+  // },
+  // varietyName: {
+  //   _json: require('../../../../bottlebooks-server/architecture/validvalues/validvalues/grapes.json'),
+  //   props: { addForm: false },
+  // },
+};
+module.exports = extractAll;
+
+function extractAll() {
+  const r = Object.entries(all)
+    .sort()
+    .map(([validValueCategory, vv]) => {
+      const _mapping = vv._mapping;
+      let addForm = true;
+      const withoutTranslations = ['varietyName', 'awards'].find(
+        (category) => category === validValueCategory
+      );
+      const keyIsTitle = ['varietyName'].includes(validValueCategory);
+      if (vv._json) {
+        vv = vv._json;
+        addForm = vv.props?.addForm;
+      }
+      const i18n = {};
+      const _all = vv._all || {};
+      const keys = Object.keys(vv);
+      const tsVV = keys.reduce((acc, locale) => {
+        if (validValueCategory === 'awards') {
+          if (locale === '_all') locale = 'en_US';
+          else return acc; //ignore noAwardsYet
+        }
+
+        //assume _all as english version when en_US is not defined in json file.
+        if (locale === '_all' && !keys?.includes('en_US')) locale = 'en_US';
+        if (locale === 'sort') {
+          if ('none' !== vv[locale]) {
+            throw new Error(`Unhandled ${validValueCategory} sort=${locale}`);
+          }
+          return acc;
+        } else if (locale === '_all') {
+          return acc;
+        }
+        const oneLocaleValidValues = { ..._all, ...vv[locale] };
+        const localeParts = locale.split('_');
+        locale = localeParts[0];
+        const newValidValues = Object.keys(oneLocaleValidValues)
+          .sort()
+          .reduce((acc, key) => {
+            const newKey = `validValues.${validValueCategory}.${key}`;
+            const title = oneLocaleValidValues[key];
+            i18n[locale] = i18n[locale] || {};
+            i18n[locale][newKey] = title;
+            if (locale === 'en') {
+              const logo = null;
+              let newValidValue = {
+                key,
+                title: {
+                  id: newKey,
+                  message: title,
+                },
+                frontend: logo ? { logo } : undefined,
+                form: addForm
+                  ? {
+                      tags: [],
+                      productType: [],
+                      //
+                      // description:
+                      //   // 'defineMessage(' +
+                      //   {
+                      //     comment: 'Description for ingredient, used in edit forms.',
+                      //     message: '',
+                      //   },
+                    }
+                  : {},
+              };
+              if (_mapping) {
+                const prop = Object.keys(_mapping)[0];
+                newValidValue = {
+                  ...newValidValue,
+                  [prop]: _mapping[prop]?.[key] || [],
+                };
+              }
+
+              acc = acc || {};
+              if (withoutTranslations) {
+                if (keyIsTitle) {
+                  acc[title] = { ...newValidValue, title: title, key: title };
+                } else {
+                  acc[key] = { ...newValidValue, title: title };
+                }
+              } else {
+                acc[key] = newValidValue;
+              }
+            } else {
+            }
+            return acc;
+          }, {});
+
+        // console.log(i);
+        return { ...acc, ...newValidValues };
+      }, {});
+      return { name: validValueCategory, tsVV, i18n };
+    });
+  return r;
+}

package/src/scripts/transformServerVV.js

@@ -0,0 +1,70 @@
+const { sortBy } = require('lodash');
+
+const all = {
+  // ingredient: require('@bottlebooks/graphql-server/src/resolvers/_eLabels/ELabel/validValues/off/ingredient'),
+  // eLabelCertification: require('@bottlebooks/graphql-server/src/resolvers/_eLabels/ELabel/validValues/off/eLabelCertifications'),
+  // packagingCertification: require('@bottlebooks/graphql-server/src/resolvers/_eLabels/ELabel/validValues/packagingCertifications'),
+  // productType: require('@bottlebooks/graphql-server/src/resolvers/_eLabels/ELabel/validValues/productType'),
+  // productionMethod: require('@bottlebooks/graphql-server/src/resolvers/_eLabels/ELabel/validValues/productionMethod'),
+  // responsibleConsumptionLogo: require('@bottlebooks/graphql-server/src/resolvers/_eLabels/ELabel/validValues/responsibleConsumptionLogos'),
+};
+const withoutTranslations = ['eLabelCertification', 'packagingCertification'];
+module.exports = extractAll;
+
+function extractAll() {
+  return Object.entries(all)
+    .sort()
+    .map(([validValueCategory, vv]) => {
+      const i18n = {};
+      const tsVV = sortBy(Object.entries(vv), ([key, val]) => key).reduce(
+        (acc, [key, { tags, productType, logo, locales }]) => {
+          const newKey = `validValues.${validValueCategory}.${key}`;
+          for (const locale in locales) {
+            i18n[locale] = i18n[locale] || {};
+            // Certain valid values should not be translated
+            if (
+              withoutTranslations.find(
+                (category) => category === validValueCategory
+              )
+            ) {
+              // i18n[locale][newKey] = locales.en;
+            } else {
+              const translation = locales[locale];
+              if (translation) i18n[locale][newKey] = locales[locale];
+            }
+          }
+          const validValue = {
+            key,
+            // name: locales.en,
+            title: {
+              id: newKey,
+              message: locales.en,
+            },
+            frontend: logo ? { logo } : undefined,
+            form: {
+              tags,
+              productType,
+              //
+              // description:
+              //   // 'defineMessage(' +
+              //   {
+              //     comment: 'Description for ingredient, used in edit forms.',
+              //     message: '',
+              //   },
+            },
+          };
+
+          // Certain valid values should not be translated
+          if (withoutTranslations.includes(validValueCategory)) {
+            validValue.title = locales.en;
+          }
+          // console.log(i);
+          acc[key] = validValue;
+          return acc;
+        },
+        {}
+      );
+      return { name: validValueCategory, tsVV, i18n };
+    });
+  // ['sk'].map((locale) => {
+}

package/src/scripts/writeFields.not.test.js

@@ -0,0 +1,60 @@
+const fs = require('fs');
+const path = require('path');
+const transformFields = require('./transformServerVV.js');
+const transformArchitectureVV = require('./transformArchitectureVV');
+
+describe('Transform bottlebooks-server/** legacy format valid values', () => {
+  it('run', () => {
+    const allValidValues = [
+      ...transformFields(),
+      ...transformArchitectureVV(),
+    ].filter(Boolean);
+    const i18All = {};
+    for (const { name, tsVV, i18n } of allValidValues) {
+      expect(tsVV).not.toBeUndefined();
+      expect(i18n).not.toBeUndefined();
+
+      // Building content for i18n json files.
+      for (const locale in i18n) {
+        i18All[locale] = { ...i18All[locale], ...i18n[locale] };
+      }
+      fs.writeFileSync(
+        path.resolve(__dirname, `../validValues/json/${name}.js`),
+        "import { defineMessage } from '@lingui/macro';\n" +
+          'const validValues = \n' +
+          JSON.stringify(tsVV, null, 2).replace(
+            /"title": \{(.*?(.|[\n])*?)\}/g,
+            '"title": defineMessage({$1})'
+          ),
+        { encoding: 'utf8' }
+      );
+    }
+    for (const locale in i18All) {
+      fs.writeFileSync(
+        path.resolve(__dirname, `../locales/json/${locale}.json`),
+        JSON.stringify(i18All[locale], null, 2),
+        { encoding: 'utf8' }
+      );
+
+      if (locale !== 'en') {
+        let po =
+          'msgid ""\n' +
+          'msgstr ""\n' +
+          '"POT-Creation-Date: 2022-10-26 17:23+0200"\n' +
+          '"MIME-Version: 1.0"\n' +
+          '"Content-Type: text/plain; charset=utf-8"\n' +
+          '"Content-Transfer-Encoding: 8bit"\n' +
+          '"X-Generator: @lingui/cli"\n' +
+          `"Language: ${locale}"\n\n`;
+        for (const prop in i18All[locale]) {
+          po += `msgid "${prop}"\nmsgstr "${i18All[locale][prop]}"\n\n`;
+        }
+        fs.writeFileSync(
+          path.resolve(__dirname, `../locales/po/${locale}.po`),
+          po,
+          { encoding: 'utf8' }
+        );
+      }
+    }
+  });
+});

package/src/style.css

@@ -0,0 +1,96 @@
+:root {
+  font-family: Inter, Avenir, Helvetica, Arial, sans-serif;
+  font-size: 16px;
+  line-height: 24px;
+  font-weight: 400;
+
+  color-scheme: light dark;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #242424;
+
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  -webkit-text-size-adjust: 100%;
+}
+
+a {
+  font-weight: 500;
+  color: #646cff;
+  text-decoration: inherit;
+}
+a:hover {
+  color: #535bf2;
+}
+
+body {
+  margin: 0;
+  display: flex;
+  place-items: center;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+h1 {
+  font-size: 3.2em;
+  line-height: 1.1;
+}
+
+#app {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 2rem;
+}
+
+.logo {
+  height: 6em;
+  padding: 1.5em;
+  will-change: filter;
+}
+.logo:hover {
+  filter: drop-shadow(0 0 2em #646cffaa);
+}
+.logo.vanilla:hover {
+  filter: drop-shadow(0 0 2em #3178c6aa);
+}
+
+.card {
+  padding: 2em;
+}
+
+.read-the-docs {
+  color: #888;
+}
+
+button {
+  border-radius: 8px;
+  border: 1px solid transparent;
+  padding: 0.6em 1.2em;
+  font-size: 1em;
+  font-weight: 500;
+  font-family: inherit;
+  background-color: #1a1a1a;
+  cursor: pointer;
+  transition: border-color 0.25s;
+}
+button:hover {
+  border-color: #646cff;
+}
+button:focus,
+button:focus-visible {
+  outline: 4px auto -webkit-focus-ring-color;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    color: #213547;
+    background-color: #ffffff;
+  }
+  a:hover {
+    color: #747bff;
+  }
+  button {
+    background-color: #f9f9f9;
+  }
+}