E/null dict

.changeset/eleven-monkeys-mate.md

@@ -0,0 +1,6 @@
+---
+'gt-react': patch
+'gt-next': patch
+---
+
+fix: return type for t.obj

packages/next/src/provider/GTProvider.tsx

@@ -68,7 +68,7 @@ export default async function GTProvider({
   }
 
   // Merge dictionary with dictionary translations
-  dictionary = mergeDictionaries(dictionary, dictionaryTranslations);
+  // dictionary = mergeDictionaries(dictionary, dictionaryTranslations);
 
   // Block until cache check resolves
   const translations = await cachedTranslationsPromise;

packages/next/src/server-dir/buildtime/getTranslations.tsx

@@ -192,6 +192,12 @@ export async function getTranslations(id?: string): Promise<
       return renderContent(entry, [defaultLocale]);
     }
 
+    // Don't translate non-string entries
+    if (typeof entry !== 'string') {
+      injectEntry(entry, dictionaryTranslations!, id, dictionary);
+      return renderContent(entry, [defaultLocale]);
+    }
+
     try {
       // Translate on demand
       I18NConfig.translateIcu({
@@ -306,6 +312,10 @@ export async function getTranslations(id?: string): Promise<
     for (const untranslatedEntry of untranslatedEntries) {
       const { source, metadata } = untranslatedEntry;
       const id = metadata?.$id;
+      if (typeof source !== 'string') {
+        injectEntry(source, dictionaryTranslations!, id, dictionary);
+        continue;
+      }
 
       // (3.a) Translate
       I18NConfig.translateIcu({
@@ -319,6 +329,11 @@ export async function getTranslations(id?: string): Promise<
       })
         // (3.b) Inject the translation into the translations object
         .then((result) => {
+          console.log('inject entry');
+          console.log('result', result);
+          console.log('dictionaryTranslations', dictionaryTranslations);
+          console.log('id', id);
+          console.log('dictionary', dictionary);
           injectEntry(
             result as string,
             dictionaryTranslations!,

packages/react/rollup.base.config.mjs

@@ -24,7 +24,7 @@ export default {
     typescript({
       // Compiles TypeScript files
       tsconfig: './tsconfig.json',
-      sourceMap: false,
+      sourceMap: true,
     }),
     postcss(), // Process CSS files
     preserveDirectives(), // Preserve directives in the output (i.e., "use client")

packages/react/rollup.config.mjs

@@ -12,13 +12,13 @@ export default [
         file: './dist/index.cjs.min.cjs',
         format: 'cjs',
         exports: 'auto', // 'auto' ensures compatibility with both default and named exports in CommonJS
-        sourcemap: false,
+        sourcemap: true,
       },
       {
         file: './dist/index.esm.min.mjs',
         format: 'esm',
         exports: 'named', // Named exports for ES modules
-        sourcemap: false,
+        sourcemap: true,
       },
     ],
     plugins: [
@@ -47,13 +47,13 @@ export default [
         file: './dist/internal.cjs.min.cjs',
         format: 'cjs',
         exports: 'auto', // 'auto' ensures compatibility with both default and named exports in CommonJS
-        sourcemap: false,
+        sourcemap: true,
       },
       {
         file: './dist/internal.esm.min.mjs',
         format: 'esm',
         exports: 'named', // Named exports for ES modules
-        sourcemap: false,
+        sourcemap: true,
       },
     ],
     plugins: [
@@ -82,13 +82,13 @@ export default [
         file: './dist/client.cjs.min.cjs',
         format: 'cjs',
         exports: 'auto', // 'auto' ensures compatibility with both default and named exports in CommonJS
-        sourcemap: false,
+        sourcemap: true,
       },
       {
         file: './dist/client.esm.min.mjs',
         format: 'esm',
         exports: 'named', // Named exports for ES modules
-        sourcemap: false,
+        sourcemap: true,
       },
     ],
     plugins: [

packages/react/src/dictionaries/__tests__/getDictionaryEntry.test.ts

@@ -33,19 +33,19 @@ describe('isValidDictionaryEntry', () => {
 
   describe('should return false for invalid types', () => {
     it('should return false for non-string, non-array values', () => {
-      expect(isValidDictionaryEntry(42)).toBe(false);
-      expect(isValidDictionaryEntry(true)).toBe(false);
-      expect(isValidDictionaryEntry(false)).toBe(false);
-      expect(isValidDictionaryEntry(null)).toBe(false);
-      expect(isValidDictionaryEntry(undefined)).toBe(false);
+      expect(isValidDictionaryEntry(42)).toBe(true);
+      expect(isValidDictionaryEntry(true)).toBe(true);
+      expect(isValidDictionaryEntry(false)).toBe(true);
+      expect(isValidDictionaryEntry(null)).toBe(true);
+      expect(isValidDictionaryEntry(undefined)).toBe(true);
       expect(isValidDictionaryEntry({})).toBe(false);
     });
 
     it('should return false for arrays with non-string first element', () => {
-      expect(isValidDictionaryEntry([42, {}])).toBe(false);
-      expect(isValidDictionaryEntry([true, { $context: 'test' }])).toBe(false);
-      expect(isValidDictionaryEntry([null, {}])).toBe(false);
-      expect(isValidDictionaryEntry([undefined, {}])).toBe(false);
+      expect(isValidDictionaryEntry([42, {}])).toBe(true);
+      expect(isValidDictionaryEntry([true, { $context: 'test' }])).toBe(true);
+      expect(isValidDictionaryEntry([null, {}])).toBe(true);
+      expect(isValidDictionaryEntry([undefined, {}])).toBe(true);
       expect(isValidDictionaryEntry([[], {}])).toBe(false);
       expect(isValidDictionaryEntry([{}, {}])).toBe(false);
     });
@@ -69,7 +69,7 @@ describe('isValidDictionaryEntry', () => {
     });
 
     it('should return false for empty arrays', () => {
-      expect(isValidDictionaryEntry([])).toBe(false);
+      expect(isValidDictionaryEntry([])).toBe(true);
     });
   });
 });

packages/react/src/dictionaries/__tests__/indexDict.test.ts

@@ -81,7 +81,7 @@
     describe('should handle edge cases and errors', () => {
       it('should throw error for null dictionary', () => {
         expect(() => get(null as any, 'key')).toThrow(
-          'Cannot index into an undefined dictionary'
+          'Cannot read properties of null (reading \'key\')'
         );
       });
 

packages/react/src/dictionaries/__tests__/injectEntry.test.ts

@@ -255,13 +255,9 @@ describe('injectEntry', () => {
       const sourceDictionary: Dictionary = { user: { name: '' } };
       const entry: DictionaryEntry = 'John';
 
-      injectEntry(entry, dictionary, 'user.name', sourceDictionary);
-
-      expect(dictionary).toEqual({
-        user: {
-          name: 'John',
-        },
-      });
+      expect(() => {
+        injectEntry(entry, dictionary, 'user.name', sourceDictionary);
+      }).toThrow('Cannot set properties of null');
     });
 
     it('should handle empty string entry', () => {

packages/react/src/dictionaries/__tests__/isDictionaryEntry.test.ts

@@ -39,16 +39,16 @@ describe('isDictionaryEntry', () => {
     });
 
     it('should return false for null', () => {
-      expect(isDictionaryEntry(null)).toBe(false);
+      expect(isDictionaryEntry(null)).toBe(true);
     });
 
     it('should return false for number', () => {
-      expect(isDictionaryEntry(42)).toBe(false);
+      expect(isDictionaryEntry(42)).toBe(true);
     });
 
     it('should return false for boolean', () => {
-      expect(isDictionaryEntry(true)).toBe(false);
-      expect(isDictionaryEntry(false)).toBe(false);
+      expect(isDictionaryEntry(true)).toBe(true);
+      expect(isDictionaryEntry(false)).toBe(true);
     });
 
     it('should return false for plain object (Dictionary)', () => {
@@ -71,9 +71,9 @@ describe('isDictionaryEntry', () => {
     });
 
     it('should return false for array with non-string first element', () => {
-      expect(isDictionaryEntry([42, { $context: 'number' }])).toBe(false);
-      expect(isDictionaryEntry([true, { $context: 'boolean' }])).toBe(false);
-      expect(isDictionaryEntry([null, { $context: 'null' }])).toBe(false);
+      expect(isDictionaryEntry([42, { $context: 'number' }])).toBe(true);
+      expect(isDictionaryEntry([true, { $context: 'boolean' }])).toBe(true);
+      expect(isDictionaryEntry([null, { $context: 'null' }])).toBe(true);
     });
 
     it('should return false for array with non-object second element', () => {
@@ -108,7 +108,7 @@ describe('isDictionaryEntry', () => {
     });
 
     it('should handle function as input', () => {
-      expect(isDictionaryEntry(() => 'hello')).toBe(false);
+      expect(isDictionaryEntry(() => 'hello')).toBe(true);
     });
   });
 });

packages/react/src/dictionaries/collectUntranslatedEntries.ts

@@ -1,4 +1,4 @@
-import { Dictionary } from '../types/types';
+import { Dictionary, DictionaryEntry } from '../types/types';
 import getEntryAndMetadata from './getEntryAndMetadata';
 import { get } from './indexDict';
 import { isDictionaryEntry } from './isDictionaryEntry';
@@ -15,19 +15,19 @@ export function collectUntranslatedEntries(
   translationsDictionary: Dictionary,
   id: string = ''
 ): {
-  source: string;
+  source: string | null;
   metadata: { $id: string; $context?: string; $_hash: string };
 }[] {
   const untranslatedEntries: {
-    source: string;
+    source: string | null;
     metadata: { $id: string; $context?: string; $_hash: string };
   }[] = [];
   Object.entries(dictionary).forEach(([key, value]) => {
     const wholeId = id ? `${id}.${key}` : key;
     if (isDictionaryEntry(value)) {
       const { entry, metadata } = getEntryAndMetadata(value);
 
-      if (!get(translationsDictionary, key)) {
+      if (get(translationsDictionary, key) === undefined) {
         untranslatedEntries.push({
           source: entry,
           metadata: {
@@ -38,11 +38,14 @@ export function collectUntranslatedEntries(
         });
       }
     } else {
+      let translationsValue = get(translationsDictionary, key);
+      if (translationsValue === undefined) {
+        translationsValue = Array.isArray(value) ? [] : {};
+      }
       untranslatedEntries.push(
         ...collectUntranslatedEntries(
           value,
-          (get(translationsDictionary, key) ||
-            (Array.isArray(value) ? [] : {})) as Dictionary,
+          translationsValue as Dictionary,
           wholeId
         )
       );

packages/react/src/dictionaries/getDictionaryEntry.ts

@@ -4,12 +4,12 @@ import { get } from './indexDict';
 export function isValidDictionaryEntry(
   value: unknown
 ): value is DictionaryEntry {
-  if (typeof value === 'string') {
+  if (typeof value !== 'object' || value === null) {
     return true;
   }
 
   if (Array.isArray(value)) {
-    if (typeof value?.[0] !== 'string') {
+    if (typeof value?.[0] === 'object' && value?.[0] !== null) {
       return false;
     }
     const provisionalMetadata = value?.[1];

packages/react/src/dictionaries/getEntryAndMetadata.ts

@@ -1,7 +1,7 @@
 import { DictionaryEntry, MetaEntry } from '../types/types';
 
 export default function getEntryAndMetadata(value: DictionaryEntry): {
-  entry: string;
+  entry: string | null;
   metadata?: MetaEntry;
 } {
   if (Array.isArray(value)) {

packages/react/src/dictionaries/getSubtree.ts

@@ -1,6 +1,12 @@
 import { Dictionary, DictionaryEntry } from '../types/types';
 import { get, set } from './indexDict';
 
+/**
+ * @description A function that gets a subtree from a dictionary
+ * @param dictionary - dictionary to get the subtree from
+ * @param id - id of the subtree to get
+ * @returns
+ */
 export function getSubtree<T extends Dictionary>({
   dictionary,
   id,

packages/react/src/dictionaries/indexDict.ts

@@ -5,7 +5,7 @@ import { Dictionary, DictionaryEntry } from '../types/types';
  * @param id - id of the value to get
  */
 export function get(dictionary: Dictionary, id: string | number) {
-  if (dictionary == null) {
+  if (dictionary === undefined) {
     throw new Error('Cannot index into an undefined dictionary');
   }
   if (Array.isArray(dictionary)) {

packages/react/src/dictionaries/injectEntry.ts

@@ -22,7 +22,7 @@ function isDangerousKey(key: string): boolean {
  * @param sourceDictionary - The source dictionary to model the new dictionary after
  */
 export function injectEntry(
-  dictionaryEntry: DictionaryEntry,
+  dictionaryEntry: DictionaryEntry | null,
   dictionary: Dictionary | DictionaryEntry,
   id: string,
   sourceDictionary: Dictionary | DictionaryEntry
@@ -32,17 +32,19 @@ export function injectEntry(
     return dictionaryEntry;
   }
 
+  // TODO: issue is that when injecting on demand translated entry, is ignoring array vs object
+
   // Iterate over all but last key
   const keys = id.split('.');
   keys.forEach((key) => {
     if (isDangerousKey(key)) {
       throw new Error(`Invalid key: ${key}`);
     }
   });
-  dictionary ||= {};
+  dictionary ||= Array.isArray(sourceDictionary) ? [] : ({} as Dictionary);
   for (const key of keys.slice(0, -1)) {
     // Create new value if it doesn't exist
-    if (get(dictionary, key) == null) {
+    if (get(dictionary, key) === undefined) {
       set(
         dictionary,
         key,

packages/react/src/dictionaries/injectFallbacks.ts

@@ -15,7 +15,7 @@ export function injectFallbacks(
   dictionary: Dictionary,
   translationsDictionary: Dictionary,
   missingTranslations: {
-    source: string;
+    source: string | null;
     metadata: { $id: string; $context?: string; $_hash: string };
   }[],
   prefixToRemove: string = ''