@terraware/web-components 4.3.3 → 5.0.1-rc.0

package/strings/export.js

@@ -0,0 +1,116 @@
+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.
+ *
+ * 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.
+ */
+const GENERATED_HEADER = '/* Generated from the CSV files in csv/ by `yarn generate-strings`. Do not edit. */';
+
+/**
+ * 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;
+  }, {});
+};
+
+/**
+ * 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
+  });
+};
+
+/**
+ * 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 = path.resolve(targetDir, `strings-${locale}.ts`);
+  await writeFile(targetPath, await stringsToTypeScript(stringsMap, targetPath), {
+    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'
+    }));
+  }
+  await exportStrings(englishStringsMap, stringsMap, locale, targetDir, defaultToEnglish);
+  if (locale === 'en') {
+    await exportStrings(englishStringsMap, generateGibberish(englishStringsMap), 'gx', targetDir, defaultToEnglish);
+  }
+};
+
+/**
+ * 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;
+};
+
+export { convertAllLocales, convertCsvFile, csvToStrings, generateGibberish, stringsToTypeScript };

package/strings/index.d.ts

@@ -0,0 +1,22 @@
+import { strings as en } from './strings-en';
+/**
+ * The set of strings every locale provides. The English table is the source of truth for the list
+ * of keys.
+ */
+export type ComponentStrings = typeof en;
+/**
+ * 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').
+ */
+export declare const setLocale: (locale: string) => void;
+/** The resolved locale, which is also the locale to hand to Intl and other formatters. */
+export declare const getLocale: () => string;
+/**
+ * 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.
+ */
+export declare const getStrings: () => ComponentStrings;
+export declare const useStrings: () => ComponentStrings;
+//# sourceMappingURL=index.d.ts.map

package/strings/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/strings/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,IAAI,EAAE,EAAE,MAAM,cAAc,CAAC;AAK7C;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,EAAE,CAAC;AAgBzC;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,KAAG,IAS1C,CAAC;AAEF,0FAA0F;AAC1F,eAAO,MAAM,SAAS,QAAO,MAAuB,CAAC;AAErD;;;GAGG;AACH,eAAO,MAAM,UAAU,QAAO,gBAAkC,CAAC;AAUjE,eAAO,MAAM,UAAU,QAAO,gBAA2E,CAAC"}

package/strings/index.js

@@ -0,0 +1,62 @@
+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: strings$3,
+  fr: strings$2,
+  gx: strings$1
+};
+
+/**
+ * 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();
+
+/**
+ * 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());
+};
+
+/** 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);
+
+export { getLocale, getStrings, setLocale, useStrings };

package/strings/locales.d.ts

@@ -0,0 +1,38 @@
+export interface LocaleDetails {
+    /**
+     * Locale identifier. This must start with a language tag (2 or 3 letters) and may optionally
+     * have a hyphen and a location code. For example, 'en' or 'en-US'.
+     */
+    id: string;
+    /**
+     * Name of the locale as it appears in a locale selector. This will typically be the name of the
+     * locale in whatever language the locale uses. That is, 'Español' and not 'Spanish'.
+     */
+    name: string;
+    /**
+     * Whether this locale is in development and not ready for production.
+     */
+    inDevelopment?: boolean;
+}
+/** Supported locales in the order they should appear in a locale selector. */
+export declare const supportedLocales: LocaleDetails[];
+/**
+ * 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.
+ */
+export declare const getSupportedLocales: (includeInDevelopment?: boolean) => LocaleDetails[];
+/**
+ * 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.
+ */
+export declare const findLocaleDetails: (locales: LocaleDetails[], locale: string) => LocaleDetails;
+//# sourceMappingURL=locales.d.ts.map

package/strings/locales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../src/strings/locales.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,EAAE,EAAE,MAAM,CAAC;IACX;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,EAAE,aAAa,EAK3C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,8BAA4B,KAAG,aAAa,EACsB,CAAC;AAEvG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,GAAI,SAAS,aAAa,EAAE,EAAE,QAAQ,MAAM,KAAG,aAQ1E,CAAC"}

package/strings/locales.js

@@ -0,0 +1,42 @@
+/** 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.d.ts

@@ -0,0 +1,52 @@
+export declare const strings: {
+    ADD_ANNOTATION: string;
+    ANNOTATION_DESCRIPTION_TOOLTIP: string;
+    ANNOTATION_LABEL_TOOLTIP: string;
+    ANNOTATION_TITLE_TOOLTIP: string;
+    ANNOTATIONS: string;
+    AR: string;
+    ARROW_KEYS: string;
+    AUTO_ROTATE: string;
+    BOUNDED_FLY: string;
+    CAMERA_FOCUS_POINT: string;
+    CAMERA_INFO: string;
+    CAMERA_POSITION: string;
+    CANCEL: string;
+    CHOOSE_FILE: string;
+    CONTROLS: string;
+    CTRL: string;
+    DELETE_ANNOTATION: string;
+    DESCRIPTION: string;
+    DESELECT_ANNOTATION: string;
+    EDIT: string;
+    EDIT_ANNOTATION: string;
+    EXISTING: string;
+    FILE_SELECTED: string;
+    FLY: string;
+    FLY_FASTER: string;
+    FLY_SLOWER: string;
+    FREE_FLY: string;
+    IMAGES: string;
+    LABEL: string;
+    LEFT_MOUSE: string;
+    LOOK: string;
+    MIDDLE_MOUSE: string;
+    MOUSE_WHEEL: string;
+    NEW: string;
+    ORBIT: string;
+    PAN: string;
+    PINCH: string;
+    REPLACE_FILE: string;
+    RESET_CAMERA: string;
+    RIGHT_MOUSE: string;
+    SAVE: string;
+    SHIFT: string;
+    SWIPE: string;
+    TITLE: string;
+    TOUCH_DRAG: string;
+    UPLOAD_FILES: string;
+    UPLOAD_FILES_DESCRIPTION: string;
+    VR: string;
+    ZOOM: string;
+};
+//# sourceMappingURL=strings-en.d.ts.map

package/strings/strings-en.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings-en.d.ts","sourceRoot":"","sources":["../../src/strings/strings-en.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDnB,CAAC"}

package/strings/strings-en.js

@@ -0,0 +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'
+};
+
+export { strings };

package/strings/strings-es.d.ts

@@ -0,0 +1,52 @@
+export declare const strings: {
+    ADD_ANNOTATION: string;
+    ANNOTATION_DESCRIPTION_TOOLTIP: string;
+    ANNOTATION_LABEL_TOOLTIP: string;
+    ANNOTATION_TITLE_TOOLTIP: string;
+    ANNOTATIONS: string;
+    AR: string;
+    ARROW_KEYS: string;
+    AUTO_ROTATE: string;
+    BOUNDED_FLY: string;
+    CAMERA_FOCUS_POINT: string;
+    CAMERA_INFO: string;
+    CAMERA_POSITION: string;
+    CANCEL: string;
+    CHOOSE_FILE: string;
+    CONTROLS: string;
+    CTRL: string;
+    DELETE_ANNOTATION: string;
+    DESCRIPTION: string;
+    DESELECT_ANNOTATION: string;
+    EDIT: string;
+    EDIT_ANNOTATION: string;
+    EXISTING: string;
+    FILE_SELECTED: string;
+    FLY: string;
+    FLY_FASTER: string;
+    FLY_SLOWER: string;
+    FREE_FLY: string;
+    IMAGES: string;
+    LABEL: string;
+    LEFT_MOUSE: string;
+    LOOK: string;
+    MIDDLE_MOUSE: string;
+    MOUSE_WHEEL: string;
+    NEW: string;
+    ORBIT: string;
+    PAN: string;
+    PINCH: string;
+    REPLACE_FILE: string;
+    RESET_CAMERA: string;
+    RIGHT_MOUSE: string;
+    SAVE: string;
+    SHIFT: string;
+    SWIPE: string;
+    TITLE: string;
+    TOUCH_DRAG: string;
+    UPLOAD_FILES: string;
+    UPLOAD_FILES_DESCRIPTION: string;
+    VR: string;
+    ZOOM: string;
+};
+//# sourceMappingURL=strings-es.d.ts.map

package/strings/strings-es.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings-es.d.ts","sourceRoot":"","sources":["../../src/strings/strings-es.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDnB,CAAC"}

package/strings/strings-es.js

@@ -0,0 +1,54 @@
+/* Generated from the CSV files in csv/ by `yarn generate-strings`. Do not edit. */
+const strings = {
+  ADD_ANNOTATION: 'Agregar anotación',
+  ANNOTATION_DESCRIPTION_TOOLTIP: 'Detalles o contexto adicional sobre esta anotación',
+  ANNOTATION_LABEL_TOOLTIP: 'Identificador breve que se muestra en el punto destacado de la anotación',
+  ANNOTATION_TITLE_TOOLTIP: 'Título principal de la anotación',
+  ANNOTATIONS: 'Anotaciones',
+  AR: 'RA',
+  ARROW_KEYS: 'Flechas del teclado',
+  AUTO_ROTATE: 'Rotación automática',
+  BOUNDED_FLY: 'Vuelo delimitado',
+  CAMERA_FOCUS_POINT: 'Punto de enfoque',
+  CAMERA_INFO: 'Información de la cámara',
+  CAMERA_POSITION: 'Posición',
+  CANCEL: 'Cancelar',
+  CHOOSE_FILE: 'Seleccione archivo...',
+  CONTROLS: 'Controles',
+  CTRL: 'Ctrl',
+  DELETE_ANNOTATION: 'Eliminar anotación',
+  DESCRIPTION: 'Descripción',
+  DESELECT_ANNOTATION: 'Deseleccionar anotación',
+  EDIT: 'Editar',
+  EDIT_ANNOTATION: 'Editar anotación',
+  EXISTING: 'Existente',
+  FILE_SELECTED: 'Archivo seleccionado',
+  FLY: 'Volar',
+  FLY_FASTER: 'Volar más rápido',
+  FLY_SLOWER: 'Volar más lento',
+  FREE_FLY: 'Vuelo libre',
+  IMAGES: 'Imágenes',
+  LABEL: 'Etiqueta',
+  LEFT_MOUSE: 'Botón izquierdo del ratón',
+  LOOK: 'Mirar',
+  MIDDLE_MOUSE: 'Botón central del ratón',
+  MOUSE_WHEEL: 'Rueda del ratón',
+  NEW: 'Nuevo',
+  ORBIT: 'Orbitar',
+  PAN: 'Desplazar',
+  PINCH: 'Pellizcar',
+  REPLACE_FILE: 'Reemplazar archivo...',
+  RESET_CAMERA: 'Restablecer cámara',
+  RIGHT_MOUSE: 'Botón derecho del ratón',
+  SAVE: 'Guardar',
+  SHIFT: 'Shift',
+  SWIPE: 'Deslizar',
+  TITLE: 'Título',
+  TOUCH_DRAG: 'Tocar y arrastrar',
+  UPLOAD_FILES: 'Subir archivos',
+  UPLOAD_FILES_DESCRIPTION: 'Buscar o arrastrar y soltar archivos.',
+  VR: 'RV',
+  ZOOM: 'Acercar/alejar'
+};
+
+export { strings };

package/strings/strings-fr.d.ts

@@ -0,0 +1,52 @@
+export declare const strings: {
+    ADD_ANNOTATION: string;
+    ANNOTATION_DESCRIPTION_TOOLTIP: string;
+    ANNOTATION_LABEL_TOOLTIP: string;
+    ANNOTATION_TITLE_TOOLTIP: string;
+    ANNOTATIONS: string;
+    AR: string;
+    ARROW_KEYS: string;
+    AUTO_ROTATE: string;
+    BOUNDED_FLY: string;
+    CAMERA_FOCUS_POINT: string;
+    CAMERA_INFO: string;
+    CAMERA_POSITION: string;
+    CANCEL: string;
+    CHOOSE_FILE: string;
+    CONTROLS: string;
+    CTRL: string;
+    DELETE_ANNOTATION: string;
+    DESCRIPTION: string;
+    DESELECT_ANNOTATION: string;
+    EDIT: string;
+    EDIT_ANNOTATION: string;
+    EXISTING: string;
+    FILE_SELECTED: string;
+    FLY: string;
+    FLY_FASTER: string;
+    FLY_SLOWER: string;
+    FREE_FLY: string;
+    IMAGES: string;
+    LABEL: string;
+    LEFT_MOUSE: string;
+    LOOK: string;
+    MIDDLE_MOUSE: string;
+    MOUSE_WHEEL: string;
+    NEW: string;
+    ORBIT: string;
+    PAN: string;
+    PINCH: string;
+    REPLACE_FILE: string;
+    RESET_CAMERA: string;
+    RIGHT_MOUSE: string;
+    SAVE: string;
+    SHIFT: string;
+    SWIPE: string;
+    TITLE: string;
+    TOUCH_DRAG: string;
+    UPLOAD_FILES: string;
+    UPLOAD_FILES_DESCRIPTION: string;
+    VR: string;
+    ZOOM: string;
+};
+//# sourceMappingURL=strings-fr.d.ts.map

package/strings/strings-fr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings-fr.d.ts","sourceRoot":"","sources":["../../src/strings/strings-fr.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDnB,CAAC"}

package/strings/strings-fr.js

@@ -0,0 +1,54 @@
+/* Generated from the CSV files in csv/ by `yarn generate-strings`. Do not edit. */
+const strings = {
+  ADD_ANNOTATION: 'Ajouter une annotation',
+  ANNOTATION_DESCRIPTION_TOOLTIP: 'Détails ou contexte supplémentaires concernant cette annotation',
+  ANNOTATION_LABEL_TOOLTIP: 'Identifiant court affiché sur le point d’annotation',
+  ANNOTATION_TITLE_TOOLTIP: 'Titre principal de l’annotation',
+  ANNOTATIONS: 'Annotations',
+  AR: 'RA',
+  ARROW_KEYS: 'Touches fléchées',
+  AUTO_ROTATE: 'Rotation automatique',
+  BOUNDED_FLY: 'Vol limité',
+  CAMERA_FOCUS_POINT: 'Point de mise au point',
+  CAMERA_INFO: 'Informations sur la caméra',
+  CAMERA_POSITION: 'Position',
+  CANCEL: 'Annuler',
+  CHOOSE_FILE: 'Choisissez le fichier...',
+  CONTROLS: 'Commandes',
+  CTRL: 'Ctrl',
+  DELETE_ANNOTATION: 'Supprimer l’annotation',
+  DESCRIPTION: 'Description',
+  DESELECT_ANNOTATION: 'Désélectionner l’annotation',
+  EDIT: 'Modifier',
+  EDIT_ANNOTATION: 'Modifier l’annotation',
+  EXISTING: 'Existant',
+  FILE_SELECTED: 'Fichier sélectionné',
+  FLY: 'Voler',
+  FLY_FASTER: 'Voler plus vite',
+  FLY_SLOWER: 'Voler plus lentement',
+  FREE_FLY: 'Vol libre',
+  IMAGES: 'Images',
+  LABEL: 'Étiquette',
+  LEFT_MOUSE: 'Bouton gauche de la souris',
+  LOOK: 'Regarder',
+  MIDDLE_MOUSE: 'Bouton central de la souris',
+  MOUSE_WHEEL: 'Molette de la souris',
+  NEW: 'Nouveau',
+  ORBIT: 'Orbiter',
+  PAN: 'Déplacer',
+  PINCH: 'Pincer',
+  REPLACE_FILE: 'Remplacer le fichier...',
+  RESET_CAMERA: 'Réinitialiser la caméra',
+  RIGHT_MOUSE: 'Bouton droit de la souris',
+  SAVE: 'Sauvegarder',
+  SHIFT: 'Maj',
+  SWIPE: 'Glisser',
+  TITLE: 'Titre',
+  TOUCH_DRAG: 'Toucher + Glisser',
+  UPLOAD_FILES: 'Téléverser des fichiers',
+  UPLOAD_FILES_DESCRIPTION: 'Parcourir ou glisser-déposer des fichiers.',
+  VR: 'RV',
+  ZOOM: 'Zoom'
+};
+
+export { strings };

package/strings/strings-gx.d.ts

@@ -0,0 +1,52 @@
+export declare const strings: {
+    ADD_ANNOTATION: string;
+    ANNOTATION_DESCRIPTION_TOOLTIP: string;
+    ANNOTATION_LABEL_TOOLTIP: string;
+    ANNOTATION_TITLE_TOOLTIP: string;
+    ANNOTATIONS: string;
+    AR: string;
+    ARROW_KEYS: string;
+    AUTO_ROTATE: string;
+    BOUNDED_FLY: string;
+    CAMERA_FOCUS_POINT: string;
+    CAMERA_INFO: string;
+    CAMERA_POSITION: string;
+    CANCEL: string;
+    CHOOSE_FILE: string;
+    CONTROLS: string;
+    CTRL: string;
+    DELETE_ANNOTATION: string;
+    DESCRIPTION: string;
+    DESELECT_ANNOTATION: string;
+    EDIT: string;
+    EDIT_ANNOTATION: string;
+    EXISTING: string;
+    FILE_SELECTED: string;
+    FLY: string;
+    FLY_FASTER: string;
+    FLY_SLOWER: string;
+    FREE_FLY: string;
+    IMAGES: string;
+    LABEL: string;
+    LEFT_MOUSE: string;
+    LOOK: string;
+    MIDDLE_MOUSE: string;
+    MOUSE_WHEEL: string;
+    NEW: string;
+    ORBIT: string;
+    PAN: string;
+    PINCH: string;
+    REPLACE_FILE: string;
+    RESET_CAMERA: string;
+    RIGHT_MOUSE: string;
+    SAVE: string;
+    SHIFT: string;
+    SWIPE: string;
+    TITLE: string;
+    TOUCH_DRAG: string;
+    UPLOAD_FILES: string;
+    UPLOAD_FILES_DESCRIPTION: string;
+    VR: string;
+    ZOOM: string;
+};
+//# sourceMappingURL=strings-gx.d.ts.map

package/strings/strings-gx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings-gx.d.ts","sourceRoot":"","sources":["../../src/strings/strings-gx.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDnB,CAAC"}