@terraware/web-components 5.0.27-rc.0 → 5.0.27

package/strings/export.js

@@ -1,127 +1,186 @@
-import { parse } from "csv-parse/sync";
-import { readFile, readdir, writeFile } from "node:fs/promises";
-import node_path from "node:path";
-import { format, resolveConfig } from "prettier";
+import { parse } from 'csv-parse/sync';
+import { readdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { resolveConfig, format } from 'prettier';
+
+/**
+ * Renders the CSV string tables as TypeScript source, and finds keys in them that no source file
+ * references.
+ *
+ * This runs at build time, not at runtime. Nothing in the component runtime imports it, so its Node
+ * and CSV dependencies never reach a browser bundle. It's published rather than kept in scripts/ so
+ * that applications sharing these string tables can drive the same conversion and checks.
+ */
 const GENERATED_HEADER = '/* Generated from the CSV files in csv/ by `yarn generate-strings`. Do not edit. */';
-const csvToStrings = (csvData)=>{
-    const rows = parse(csvData, {
-        from: 2,
-        relax_column_count_less: true,
-        skip_empty_lines: true
-    });
-    return rows.reduce((result, row)=>{
-        result[row[0]] = row[1];
-        return result;
-    }, {});
+
+/**
+ * Loads a CSV strings file into an object, taking keys and values from the first two columns.
+ */
+const csvToStrings = csvData => {
+  const rows = parse(csvData, {
+    // Skip header row
+    from: 2,
+    // Only rows for strings that have comments have 3 fields.
+    relax_column_count_less: true,
+    // Skip empty "row" that is really just the terminating linefeed
+    skip_empty_lines: true
+  });
+  return rows.reduce((result, row) => {
+    result[row[0]] = row[1];
+    return result;
+  }, {});
 };
-const stringsToTypeScript = async (stringsMap, targetPath)=>{
-    const source = `${GENERATED_HEADER}\nexport const strings = ${JSON.stringify(stringsMap, null, 2)};\n`;
-    const prettierConfig = await resolveConfig(targetPath);
-    return format(source, {
-        ...prettierConfig,
-        filepath: targetPath
-    });
+
+/**
+ * Renders a strings object as a TypeScript module that exports a constant called "strings",
+ * formatted the way the repository's Prettier configuration wants it so that generating a table and
+ * formatting the tree don't fight over the result.
+ */
+const stringsToTypeScript = async (stringsMap, targetPath) => {
+  const source = `${GENERATED_HEADER}\nexport const strings = ${JSON.stringify(stringsMap, null, 2)};\n`;
+  const prettierConfig = await resolveConfig(targetPath);
+  return format(source, {
+    ...prettierConfig,
+    filepath: targetPath
+  });
 };
-const generateGibberish = (english)=>Object.fromEntries(Object.entries(english).map(([key, value])=>[
-            key,
-            value.split(' ').reverse().map((word)=>word.startsWith('{') ? word : Buffer.from(word, 'utf-8').toString('base64').replace(/=/g, '')).join(' ')
-        ]));
-const exportStrings = async (englishStrings, localizedStrings, locale, targetDir, defaultToEnglish)=>{
-    const stringsMap = {};
-    for (const key of Object.keys(englishStrings))if (key in localizedStrings) stringsMap[key] = localizedStrings[key];
-    else {
-        console.warn(`Locale ${locale} has no translation for ${key}`);
-        if (defaultToEnglish) stringsMap[key] = englishStrings[key];
+
+/**
+ * Transforms the English strings table into gibberish, which makes untranslated text obvious
+ * without waiting on a translation.
+ *
+ * 1. Split the English string into whitespace-delimited words.
+ * 2. Reverse the order of the words.
+ * 3. Render each word as a base64 encoding of its UTF-8 representation, except for words that look
+ *    like format string placeholders.
+ */
+const generateGibberish = english => Object.fromEntries(Object.entries(english).map(([key, value]) => [key, value.split(' ').reverse().map(word => word.startsWith('{') ? word : Buffer.from(word, 'utf-8').toString('base64').replace(/=/g, '')).join(' ')]));
+const exportStrings = async (englishStrings, localizedStrings, locale, targetDir, defaultToEnglish) => {
+  const stringsMap = {};
+  for (const key of Object.keys(englishStrings)) {
+    if (key in localizedStrings) {
+      stringsMap[key] = localizedStrings[key];
+    } else {
+      console.warn(`Locale ${locale} has no translation for ${key}`);
+      if (defaultToEnglish) {
+        stringsMap[key] = englishStrings[key];
+      }
     }
-    const targetPath = node_path.resolve(targetDir, `strings-${locale}.ts`);
-    await writeFile(targetPath, await stringsToTypeScript(stringsMap, targetPath), {
-        encoding: 'utf-8'
-    });
+  }
+  const targetPath = path.resolve(targetDir, `strings-${locale}.ts`);
+  await writeFile(targetPath, await stringsToTypeScript(stringsMap, targetPath), {
+    encoding: 'utf-8'
+  });
 };
-const convertCsvFile = async (csvPath, targetDir, defaultToEnglish = true)=>{
-    if (!csvPath.endsWith('.csv')) throw new Error('Cannot convert a non-CSV file');
-    const locale = node_path.basename(csvPath, '.csv');
-    const stringsMap = csvToStrings(await readFile(csvPath, {
-        encoding: 'utf-8'
+
+/**
+ * Converts a CSV strings file to a TypeScript source file that exports a constant called "strings".
+ * This will be an object that has the same keys as the English strings file; the English strings
+ * will be used for any keys that aren't translated yet.
+ *
+ * The filename is assumed to be the locale code with a ".csv" suffix. Converting the English file
+ * also writes the gibberish table, which is derived from English rather than translated.
+ */
+const convertCsvFile = async (csvPath, targetDir, defaultToEnglish = true) => {
+  if (!csvPath.endsWith('.csv')) {
+    throw new Error('Cannot convert a non-CSV file');
+  }
+  const locale = path.basename(csvPath, '.csv');
+  const stringsMap = csvToStrings(await readFile(csvPath, {
+    encoding: 'utf-8'
+  }));
+  let englishStringsMap;
+  if (locale === 'en') {
+    englishStringsMap = stringsMap;
+  } else {
+    const englishPath = path.resolve(path.dirname(csvPath), 'en.csv');
+    englishStringsMap = csvToStrings(await readFile(englishPath, {
+      encoding: 'utf-8'
     }));
-    let englishStringsMap;
-    if ('en' === locale) englishStringsMap = stringsMap;
-    else {
-        const englishPath = node_path.resolve(node_path.dirname(csvPath), 'en.csv');
-        englishStringsMap = csvToStrings(await readFile(englishPath, {
-            encoding: 'utf-8'
-        }));
-    }
-    await exportStrings(englishStringsMap, stringsMap, locale, targetDir, defaultToEnglish);
-    if ('en' === locale) await exportStrings(englishStringsMap, generateGibberish(englishStringsMap), 'gx', targetDir, defaultToEnglish);
+  }
+  await exportStrings(englishStringsMap, stringsMap, locale, targetDir, defaultToEnglish);
+  if (locale === 'en') {
+    await exportStrings(englishStringsMap, generateGibberish(englishStringsMap), 'gx', targetDir, defaultToEnglish);
+  }
 };
-const convertAllLocales = async (csvDir, stringsDir, defaultToEnglish = true)=>{
-    const csvFiles = (await readdir(csvDir)).filter((filename)=>filename.endsWith('.csv'));
-    await Promise.all(csvFiles.map((filename)=>convertCsvFile(node_path.join(csvDir, filename), stringsDir, defaultToEnglish)));
-    return csvFiles;
+
+/**
+ * Converts the CSV files for all locales to TypeScript source files. The list of locales is
+ * determined by the presence of CSV files.
+ */
+const convertAllLocales = async (csvDir, stringsDir, defaultToEnglish = true) => {
+  const csvFiles = (await readdir(csvDir)).filter(filename => filename.endsWith('.csv'));
+  await Promise.all(csvFiles.map(filename => convertCsvFile(path.join(csvDir, filename), stringsDir, defaultToEnglish)));
+  return csvFiles;
 };
-const DEFAULT_EXTENSIONS = [
-    '.ts',
-    '.js',
-    '.tsx',
-    '.jsx'
-];
-const DEFAULT_EXCLUDED_DIRECTORIES = [
-    'strings'
-];
-const findSourceFiles = async (directory, extensions = DEFAULT_EXTENSIONS, excludedDirectories = DEFAULT_EXCLUDED_DIRECTORIES)=>{
-    const entries = await readdir(directory, {
-        withFileTypes: true
-    });
-    const nested = await Promise.all(entries.map(async (entry)=>{
-        const entryPath = node_path.join(directory, entry.name);
-        if (entry.isDirectory()) return excludedDirectories.includes(entry.name) ? [] : findSourceFiles(entryPath, extensions, excludedDirectories);
-        return extensions.includes(node_path.extname(entry.name)) ? [
-            entryPath
-        ] : [];
-    }));
-    return nested.flat().sort();
+const DEFAULT_EXTENSIONS = ['.ts', '.js', '.tsx', '.jsx'];
+const DEFAULT_EXCLUDED_DIRECTORIES = ['strings'];
+const findSourceFiles = async (directory, extensions = DEFAULT_EXTENSIONS, excludedDirectories = DEFAULT_EXCLUDED_DIRECTORIES) => {
+  const entries = await readdir(directory, {
+    withFileTypes: true
+  });
+  const nested = await Promise.all(entries.map(async entry => {
+    const entryPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      return excludedDirectories.includes(entry.name) ? [] : findSourceFiles(entryPath, extensions, excludedDirectories);
+    }
+    return extensions.includes(path.extname(entry.name)) ? [entryPath] : [];
+  }));
+  return nested.flat().sort();
 };
 const STRINGS_PROPERTY_ACCESS = /\bstrings\s*\??\.\s*(\w+)/g;
 const STRINGS_INDEX_ACCESS = /\bstrings\s*(?:\?\.)?\s*\[([^\]]*)\]/g;
 const QUOTED_KEY = /(['"`])(\w+)\1/g;
-const findAccessedKeys = (source)=>[
-        ...Array.from(source.matchAll(STRINGS_PROPERTY_ACCESS), (match)=>match[1]),
-        ...Array.from(source.matchAll(STRINGS_INDEX_ACCESS)).flatMap((match)=>Array.from(match[1].matchAll(QUOTED_KEY), (literal)=>literal[2]))
-    ];
-const classifyKeys = (keys, sources)=>{
-    const accessedKeys = new Set(sources.flatMap(findAccessedKeys));
-    const identifiers = new Set(sources.flatMap((source)=>source.match(/\w+/g) ?? []));
-    const unused = [];
-    const possiblyUnused = [];
-    keys.forEach((key)=>{
-        if (accessedKeys.has(key)) return;
-        if (identifiers.has(key)) possiblyUnused.push(key);
-        else unused.push(key);
-    });
-    return {
-        unused,
-        possiblyUnused
-    };
+
+/**
+ * Returns the keys a source file reads from the strings table, either as properties
+ * (strings.SAVE) or as quoted keys inside an index expression (strings[isRead ? 'READ' : 'UNREAD']).
+ */
+const findAccessedKeys = source => [...Array.from(source.matchAll(STRINGS_PROPERTY_ACCESS), match => match[1]), ...Array.from(source.matchAll(STRINGS_INDEX_ACCESS)).flatMap(match => Array.from(match[1].matchAll(QUOTED_KEY), literal => literal[2]))];
+const classifyKeys = (keys, sources) => {
+  const accessedKeys = new Set(sources.flatMap(findAccessedKeys));
+  const identifiers = new Set(sources.flatMap(source => source.match(/\w+/g) ?? []));
+  const unused = [];
+  const possiblyUnused = [];
+  keys.forEach(key => {
+    if (accessedKeys.has(key)) {
+      return;
+    }
+    if (identifiers.has(key)) {
+      possiblyUnused.push(key);
+    } else {
+      unused.push(key);
+    }
+  });
+  return {
+    unused,
+    possiblyUnused
+  };
 };
-const findUnusedStrings = async ({ csvPath, sourceDir, extensions, excludedDirectories })=>{
-    const keys = Object.keys(csvToStrings(await readFile(csvPath, {
-        encoding: 'utf-8'
-    })));
-    const files = await findSourceFiles(sourceDir, extensions, excludedDirectories);
-    const sources = await Promise.all(files.map((file)=>readFile(file, {
-            encoding: 'utf-8'
-        })));
-    return classifyKeys(keys, sources);
+const findUnusedStrings = async ({
+  csvPath,
+  sourceDir,
+  extensions,
+  excludedDirectories
+}) => {
+  const keys = Object.keys(csvToStrings(await readFile(csvPath, {
+    encoding: 'utf-8'
+  })));
+  const files = await findSourceFiles(sourceDir, extensions, excludedDirectories);
+  const sources = await Promise.all(files.map(file => readFile(file, {
+    encoding: 'utf-8'
+  })));
+  return classifyKeys(keys, sources);
 };
-const formatUnusedStrings = ({ unused, possiblyUnused })=>{
-    const lines = 0 === unused.length ? [
-        'No unused entries found.'
-    ] : [
-        'Unused entries found:',
-        ...unused
-    ];
-    if (possiblyUnused.length > 0) lines.push('', 'Possibly unused entries (never read from strings, but the name appears elsewhere; check manually):', ...possiblyUnused);
-    return `${lines.join('\n')}\n`;
+const formatUnusedStrings = ({
+  unused,
+  possiblyUnused
+}) => {
+  const lines = unused.length === 0 ? ['No unused entries found.'] : ['Unused entries found:', ...unused];
+  if (possiblyUnused.length > 0) {
+    lines.push('', 'Possibly unused entries (never read from strings, but the name appears elsewhere; check manually):', ...possiblyUnused);
+  }
+  return `${lines.join('\n')}\n`;
 };
+
 export { classifyKeys, convertAllLocales, convertCsvFile, csvToStrings, findAccessedKeys, findSourceFiles, findUnusedStrings, formatUnusedStrings, generateGibberish, stringsToTypeScript };

package/strings/index.js

@@ -1,33 +1,62 @@
-import { useSyncExternalStore } from "react";
-import { findLocaleDetails, supportedLocales } from "./locales.js";
-import { strings } from "./strings-en.js";
-import { strings as external_strings_es_js_strings } from "./strings-es.js";
-import { strings as external_strings_fr_js_strings } from "./strings-fr.js";
-import { strings as external_strings_gx_js_strings } from "./strings-gx.js";
+import { useSyncExternalStore } from 'react';
+import { findLocaleDetails, supportedLocales } from './locales.js';
+import { strings } from './strings-en.js';
+import { strings as strings$3 } from './strings-es.js';
+import { strings as strings$2 } from './strings-fr.js';
+import { strings as strings$1 } from './strings-gx.js';
+
+/**
+ * The set of strings every locale provides. The English table is the source of truth for the list
+ * of keys.
+ */
+
 const tables = {
-    en: strings,
-    es: external_strings_es_js_strings,
-    fr: external_strings_fr_js_strings,
-    gx: external_strings_gx_js_strings
+  en: strings,
+  es: strings$3,
+  fr: strings$2,
+  gx: strings$1
 };
-const localesWithTables = ()=>supportedLocales.filter((locale)=>locale.id in tables);
+
+/**
+ * Locales we have a bundled string table for. A locale can be supported -- listed in a locale
+ * selector -- before its table lands, and resolving against the tables we actually have keeps
+ * `getLocale` and `getStrings` describing the same language.
+ */
+const localesWithTables = () => supportedLocales.filter(locale => locale.id in tables);
 let currentLocale = 'en';
 let currentStrings = strings;
 const listeners = new Set();
-const setLocale = (locale)=>{
-    const resolved = findLocaleDetails(localesWithTables(), locale).id;
-    if (resolved === currentLocale) return;
-    currentLocale = resolved;
-    currentStrings = tables[resolved] ?? strings;
-    listeners.forEach((notify)=>notify());
+
+/**
+ * Sets the locale these components render in. Consumers own the locale -- a component library has
+ * no reliable way to know whether the browser's language or a user's profile setting should win --
+ * so nothing here changes until an application calls this. Accepts a bare language tag or one with
+ * a region ('es' or 'es-MX').
+ */
+const setLocale = locale => {
+  const resolved = findLocaleDetails(localesWithTables(), locale).id;
+  if (resolved === currentLocale) {
+    return;
+  }
+  currentLocale = resolved;
+  currentStrings = tables[resolved] ?? strings;
+  listeners.forEach(notify => notify());
 };
-const getLocale = ()=>currentLocale;
-const getStrings = ()=>currentStrings;
-const subscribe = (notify)=>{
-    listeners.add(notify);
-    return ()=>{
-        listeners.delete(notify);
-    };
+
+/** The resolved locale, which is also the locale to hand to Intl and other formatters. */
+const getLocale = () => currentLocale;
+
+/**
+ * The current string table. For components, prefer `useStrings`, which re-renders on a locale
+ * change; this is for the imperative code that can't hold a hook, such as PlayCanvas scripts.
+ */
+const getStrings = () => currentStrings;
+const subscribe = notify => {
+  listeners.add(notify);
+  return () => {
+    listeners.delete(notify);
+  };
 };
-const useStrings = ()=>useSyncExternalStore(subscribe, getStrings, getStrings);
+const useStrings = () => useSyncExternalStore(subscribe, getStrings, getStrings);
+
 export { getLocale, getStrings, setLocale, useStrings };

package/strings/locales.js

@@ -1,22 +1,42 @@
-const supportedLocales = [
-    {
-        id: 'en',
-        name: 'English'
-    },
-    {
-        id: 'es',
-        name: 'Español'
-    },
-    {
-        id: 'fr',
-        name: 'Français'
-    },
-    {
-        id: 'gx',
-        name: 'Gibberish',
-        inDevelopment: true
-    }
-];
-const getSupportedLocales = (includeInDevelopment = false)=>includeInDevelopment ? supportedLocales : supportedLocales.filter((locale)=>!locale.inDevelopment);
-const findLocaleDetails = (locales, locale)=>locales.reduce((bestMatch, candidate)=>locale.startsWith(candidate.id) && (!locale.startsWith(bestMatch.id) || candidate.id.length > bestMatch.id.length) ? candidate : bestMatch);
+/** Supported locales in the order they should appear in a locale selector. */
+const supportedLocales = [{
+  id: 'en',
+  name: 'English'
+}, {
+  id: 'es',
+  name: 'Español'
+}, {
+  id: 'fr',
+  name: 'Français'
+}, {
+  id: 'gx',
+  name: 'Gibberish',
+  inDevelopment: true
+}];
+
+/**
+ * Returns the locales that should be offered to users. Locales still in development are left out
+ * unless they're asked for, which is how a consumer exposes them outside of production.
+ */
+const getSupportedLocales = (includeInDevelopment = false) => includeInDevelopment ? supportedLocales : supportedLocales.filter(locale => !locale.inDevelopment);
+
+/**
+ * Returns the locale from a list of locales that matches the user's selected language.
+ *
+ * The user's locale can include both a language and a country code, but entries in a list of
+ * languages usually don't have country codes. So we need to find the entry that is the longest
+ * prefix of the user's locale.
+ *
+ * If the locale is es-MX and the list of locales only has es, we want the es item to be selected.
+ * But if the locale is zh-CN and the list has both zh-CN and zh-TW, we want zh-CN to be selected.
+ *
+ * If none of the locales in the list matches, returns the first locale from the list. The list
+ * must not be empty.
+ */
+const findLocaleDetails = (locales, locale) => locales.reduce((bestMatch, candidate) =>
+// The best match so far is only worth keeping if it's a prefix of the requested locale too.
+// reduce() seeds with the first locale without checking it, so a leading 'en-US' would
+// otherwise be treated as a match for 'en' and never replaced.
+locale.startsWith(candidate.id) && (!locale.startsWith(bestMatch.id) || candidate.id.length > bestMatch.id.length) ? candidate : bestMatch);
+
 export { findLocaleDetails, getSupportedLocales, supportedLocales };

package/strings/strings-en.js

@@ -1,52 +1,54 @@
+/* Generated from the CSV files in csv/ by `yarn generate-strings`. Do not edit. */
 const strings = {
-    ADD_ANNOTATION: 'Add Annotation',
-    ANNOTATION_DESCRIPTION_TOOLTIP: 'Additional details or context about this annotation',
-    ANNOTATION_LABEL_TOOLTIP: 'Short identifier displayed on the annotation hotspot',
-    ANNOTATION_TITLE_TOOLTIP: 'Main heading for the annotation',
-    ANNOTATIONS: 'Annotations',
-    AR: 'AR',
-    ARROW_KEYS: 'Arrow Keys',
-    AUTO_ROTATE: 'Auto Rotate',
-    BOUNDED_FLY: 'Bounded-fly',
-    CAMERA_FOCUS_POINT: 'Focus Point',
-    CAMERA_INFO: 'Camera Info',
-    CAMERA_POSITION: 'Position',
-    CANCEL: 'Cancel',
-    CHOOSE_FILE: 'Choose File...',
-    CONTROLS: 'Controls',
-    CTRL: 'Ctrl',
-    DELETE_ANNOTATION: 'Delete Annotation',
-    DESCRIPTION: "Description",
-    DESELECT_ANNOTATION: 'Deselect Annotation',
-    EDIT: 'Edit',
-    EDIT_ANNOTATION: 'Edit Annotation',
-    EXISTING: 'Existing',
-    FILE_SELECTED: 'File Selected',
-    FLY: 'Fly',
-    FLY_FASTER: 'Fly faster',
-    FLY_SLOWER: 'Fly slower',
-    FREE_FLY: 'Free-fly',
-    IMAGES: 'Images',
-    LABEL: 'Label',
-    LEFT_MOUSE: 'Left Mouse',
-    LOOK: 'Look',
-    MIDDLE_MOUSE: 'Middle Mouse',
-    MOUSE_WHEEL: 'Mouse Wheel',
-    NEW: 'New',
-    ORBIT: 'Orbit',
-    PAN: 'Pan',
-    PINCH: 'Pinch',
-    REPLACE_FILE: 'Replace File...',
-    RESET_CAMERA: 'Reset Camera',
-    RIGHT_MOUSE: 'Right Mouse',
-    SAVE: 'Save',
-    SHIFT: 'Shift',
-    SWIPE: 'Swipe',
-    TITLE: 'Title',
-    TOUCH_DRAG: 'Touch + Drag',
-    UPLOAD_FILES: 'Upload Files',
-    UPLOAD_FILES_DESCRIPTION: 'Browse or drag and drop files.',
-    VR: 'VR',
-    ZOOM: 'Zoom'
+  ADD_ANNOTATION: 'Add Annotation',
+  ANNOTATION_DESCRIPTION_TOOLTIP: 'Additional details or context about this annotation',
+  ANNOTATION_LABEL_TOOLTIP: 'Short identifier displayed on the annotation hotspot',
+  ANNOTATION_TITLE_TOOLTIP: 'Main heading for the annotation',
+  ANNOTATIONS: 'Annotations',
+  AR: 'AR',
+  ARROW_KEYS: 'Arrow Keys',
+  AUTO_ROTATE: 'Auto Rotate',
+  BOUNDED_FLY: 'Bounded-fly',
+  CAMERA_FOCUS_POINT: 'Focus Point',
+  CAMERA_INFO: 'Camera Info',
+  CAMERA_POSITION: 'Position',
+  CANCEL: 'Cancel',
+  CHOOSE_FILE: 'Choose File...',
+  CONTROLS: 'Controls',
+  CTRL: 'Ctrl',
+  DELETE_ANNOTATION: 'Delete Annotation',
+  DESCRIPTION: 'Description',
+  DESELECT_ANNOTATION: 'Deselect Annotation',
+  EDIT: 'Edit',
+  EDIT_ANNOTATION: 'Edit Annotation',
+  EXISTING: 'Existing',
+  FILE_SELECTED: 'File Selected',
+  FLY: 'Fly',
+  FLY_FASTER: 'Fly faster',
+  FLY_SLOWER: 'Fly slower',
+  FREE_FLY: 'Free-fly',
+  IMAGES: 'Images',
+  LABEL: 'Label',
+  LEFT_MOUSE: 'Left Mouse',
+  LOOK: 'Look',
+  MIDDLE_MOUSE: 'Middle Mouse',
+  MOUSE_WHEEL: 'Mouse Wheel',
+  NEW: 'New',
+  ORBIT: 'Orbit',
+  PAN: 'Pan',
+  PINCH: 'Pinch',
+  REPLACE_FILE: 'Replace File...',
+  RESET_CAMERA: 'Reset Camera',
+  RIGHT_MOUSE: 'Right Mouse',
+  SAVE: 'Save',
+  SHIFT: 'Shift',
+  SWIPE: 'Swipe',
+  TITLE: 'Title',
+  TOUCH_DRAG: 'Touch + Drag',
+  UPLOAD_FILES: 'Upload Files',
+  UPLOAD_FILES_DESCRIPTION: 'Browse or drag and drop files.',
+  VR: 'VR',
+  ZOOM: 'Zoom'
 };
+
 export { strings };