@idealyst/translate 1.2.3

package/src/utils/__tests__/namespace.test.ts

@@ -0,0 +1,211 @@
+import { parseKey, hasNestedKey, getNestedValue, flattenKeys } from '../namespace';
+
+describe('parseKey', () => {
+  it('parses namespace:key format', () => {
+    expect(parseKey('common:greeting')).toEqual({
+      namespace: 'common',
+      localKey: 'greeting',
+    });
+  });
+
+  it('parses namespace:nested.key format', () => {
+    expect(parseKey('common:buttons.submit')).toEqual({
+      namespace: 'common',
+      localKey: 'buttons.submit',
+    });
+  });
+
+  it('parses namespace.key format', () => {
+    expect(parseKey('common.greeting')).toEqual({
+      namespace: 'common',
+      localKey: 'greeting',
+    });
+  });
+
+  it('parses deeply nested namespace.a.b.c format', () => {
+    expect(parseKey('common.buttons.primary.label')).toEqual({
+      namespace: 'common',
+      localKey: 'buttons.primary.label',
+    });
+  });
+
+  it('uses default namespace for single key', () => {
+    expect(parseKey('greeting')).toEqual({
+      namespace: 'translation',
+      localKey: 'greeting',
+    });
+  });
+
+  it('uses custom default namespace', () => {
+    expect(parseKey('greeting', 'app')).toEqual({
+      namespace: 'app',
+      localKey: 'greeting',
+    });
+  });
+
+  it('handles multiple colons', () => {
+    expect(parseKey('common:time:12:30')).toEqual({
+      namespace: 'common',
+      localKey: 'time:12:30',
+    });
+  });
+});
+
+describe('hasNestedKey', () => {
+  const obj = {
+    level1: {
+      level2: {
+        level3: 'value',
+      },
+      simple: 'test',
+    },
+    top: 'topValue',
+  };
+
+  it('returns true for existing top-level key', () => {
+    expect(hasNestedKey(obj, 'top')).toBe(true);
+  });
+
+  it('returns true for existing nested key', () => {
+    expect(hasNestedKey(obj, 'level1.level2.level3')).toBe(true);
+  });
+
+  it('returns true for intermediate key', () => {
+    expect(hasNestedKey(obj, 'level1.level2')).toBe(true);
+  });
+
+  it('returns false for non-existent key', () => {
+    expect(hasNestedKey(obj, 'nonexistent')).toBe(false);
+  });
+
+  it('returns false for non-existent nested key', () => {
+    expect(hasNestedKey(obj, 'level1.nonexistent')).toBe(false);
+  });
+
+  it('returns false for path through non-object', () => {
+    expect(hasNestedKey(obj, 'top.child')).toBe(false);
+  });
+
+  it('handles empty object', () => {
+    expect(hasNestedKey({}, 'any')).toBe(false);
+  });
+});
+
+describe('getNestedValue', () => {
+  const obj = {
+    greeting: 'Hello',
+    nested: {
+      deep: {
+        value: 'Found it',
+      },
+    },
+    array: [1, 2, 3],
+  };
+
+  it('gets top-level value', () => {
+    expect(getNestedValue(obj, 'greeting')).toBe('Hello');
+  });
+
+  it('gets nested value', () => {
+    expect(getNestedValue(obj, 'nested.deep.value')).toBe('Found it');
+  });
+
+  it('gets object value', () => {
+    expect(getNestedValue(obj, 'nested.deep')).toEqual({ value: 'Found it' });
+  });
+
+  it('returns undefined for non-existent key', () => {
+    expect(getNestedValue(obj, 'nonexistent')).toBeUndefined();
+  });
+
+  it('returns undefined for non-existent nested key', () => {
+    expect(getNestedValue(obj, 'nested.nonexistent')).toBeUndefined();
+  });
+
+  it('handles array values', () => {
+    expect(getNestedValue(obj, 'array')).toEqual([1, 2, 3]);
+  });
+});
+
+describe('flattenKeys', () => {
+  it('flattens simple object', () => {
+    const obj = {
+      a: 'value1',
+      b: 'value2',
+    };
+
+    expect(flattenKeys(obj)).toEqual(['a', 'b']);
+  });
+
+  it('flattens nested object', () => {
+    const obj = {
+      buttons: {
+        submit: 'Submit',
+        cancel: 'Cancel',
+      },
+    };
+
+    expect(flattenKeys(obj)).toEqual(['buttons.submit', 'buttons.cancel']);
+  });
+
+  it('flattens deeply nested object', () => {
+    const obj = {
+      forms: {
+        validation: {
+          errors: {
+            required: 'Required',
+            email: 'Invalid email',
+          },
+        },
+      },
+    };
+
+    expect(flattenKeys(obj)).toEqual([
+      'forms.validation.errors.required',
+      'forms.validation.errors.email',
+    ]);
+  });
+
+  it('uses prefix when provided', () => {
+    const obj = {
+      submit: 'Submit',
+    };
+
+    expect(flattenKeys(obj, 'buttons')).toEqual(['buttons.submit']);
+  });
+
+  it('handles mixed nesting levels', () => {
+    const obj = {
+      simple: 'value',
+      nested: {
+        deep: 'deepValue',
+      },
+    };
+
+    expect(flattenKeys(obj)).toEqual(['simple', 'nested.deep']);
+  });
+
+  it('handles empty object', () => {
+    expect(flattenKeys({})).toEqual([]);
+  });
+
+  it('ignores arrays (treats as leaf values)', () => {
+    const obj = {
+      items: ['a', 'b', 'c'],
+    };
+
+    expect(flattenKeys(obj)).toEqual(['items']);
+  });
+
+  it('handles null values', () => {
+    const obj = {
+      nullValue: null,
+      valid: 'value',
+    };
+
+    expect(flattenKeys(obj as Record<string, unknown>)).toEqual([
+      'nullValue',
+      'valid',
+    ]);
+  });
+});

package/src/utils/index.ts

@@ -0,0 +1 @@
+export { parseKey, hasNestedKey, getNestedValue, flattenKeys } from './namespace';

package/src/utils/namespace.ts

@@ -0,0 +1,97 @@
+/**
+ * Parse a full translation key into namespace and local key parts
+ *
+ * @param fullKey - The full key (e.g., "common:buttons.submit" or "common.buttons.submit")
+ * @param defaultNamespace - Default namespace to use if not specified
+ * @returns Object with namespace and localKey
+ *
+ * @example
+ * parseKey('common:buttons.submit') // { namespace: 'common', localKey: 'buttons.submit' }
+ * parseKey('buttons.submit', 'common') // { namespace: 'common', localKey: 'buttons.submit' }
+ * parseKey('common.buttons.submit') // { namespace: 'common', localKey: 'buttons.submit' }
+ */
+export function parseKey(
+  fullKey: string,
+  defaultNamespace: string = 'translation'
+): { namespace: string; localKey: string } {
+  // Handle namespace:key format (explicit namespace separator)
+  if (fullKey.includes(':')) {
+    const [namespace, ...rest] = fullKey.split(':');
+    return { namespace, localKey: rest.join(':') };
+  }
+
+  // Handle namespace.key format (first segment is namespace if multiple segments)
+  const segments = fullKey.split('.');
+  if (segments.length > 1) {
+    return { namespace: segments[0], localKey: segments.slice(1).join('.') };
+  }
+
+  // Single key without namespace
+  return { namespace: defaultNamespace, localKey: fullKey };
+}
+
+/**
+ * Check if an object has a nested key
+ *
+ * @param obj - The object to check
+ * @param keyPath - Dot-separated key path
+ * @returns Whether the key exists
+ */
+export function hasNestedKey(obj: Record<string, unknown>, keyPath: string): boolean {
+  const parts = keyPath.split('.');
+  let current: unknown = obj;
+
+  for (const part of parts) {
+    if (current === undefined || current === null) return false;
+    if (typeof current !== 'object') return false;
+    current = (current as Record<string, unknown>)[part];
+  }
+
+  return current !== undefined;
+}
+
+/**
+ * Get a nested value from an object
+ *
+ * @param obj - The object to read from
+ * @param keyPath - Dot-separated key path
+ * @returns The value or undefined
+ */
+export function getNestedValue(
+  obj: Record<string, unknown>,
+  keyPath: string
+): unknown {
+  const parts = keyPath.split('.');
+  let current: unknown = obj;
+
+  for (const part of parts) {
+    if (current === undefined || current === null) return undefined;
+    if (typeof current !== 'object') return undefined;
+    current = (current as Record<string, unknown>)[part];
+  }
+
+  return current;
+}
+
+/**
+ * Flatten a nested object into dot-notation keys
+ *
+ * @param obj - The object to flatten
+ * @param prefix - Key prefix
+ * @returns Array of flattened keys
+ */
+export function flattenKeys(obj: Record<string, unknown>, prefix: string = ''): string[] {
+  const keys: string[] = [];
+
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      keys.push(...flattenKeys(value as Record<string, unknown>, fullKey));
+    } else {
+      keys.push(fullKey);
+    }
+  }
+
+  return keys;
+}