try to make enum work

lib/src/commands/LayoutTreeParser.test.js → lib/src/commands/LayoutTreeParser.test.ts

-const LayoutTreeParser = require('./LayoutTreeParser');
-const LayoutTypes = require('./LayoutTypes');
-const _ = require('lodash');
-const Examples = require('./LayoutExamples');
+import * as  _ from 'lodash';
+import { LayoutTreeParser } from './LayoutTreeParser';
+import { LayoutTypes } from './LayoutTypes';
+import { Examples } from './LayoutExamples';
 
 describe('LayoutTreeParser', () => {
   let uut;

lib/src/commands/LayoutTreeParser.js → lib/src/commands/LayoutTreeParser.ts

-import { LayoutTypes } from './LayoutTypes';
+import * as _ from 'lodash';
+import { LayoutTypes } from './values/LayoutTypes';
 
-const _ = require('lodash');
-
-class LayoutTreeParser {
+export class LayoutTreeParser {
   constructor() {
     this.parse = this.parse.bind(this);
   }
 
   /**
-   * returns correct layout tree of nodes which are { type, data, children }
+   * @returns correct layout tree of nodes which are { type, data, children }
    */
   parse(api) {
     if (api.topTabs) {
     };
   }
 }
-
-module.exports = LayoutTreeParser;

lib/src/commands/OptionsProcessor.test.ts

 
   it('processes colors into numeric AARRGGBB', () => {
     options.someKeyColor = 'red';
+    options.color = 'blue';
     OptionsProcessor.processOptions(options);
     expect(options.someKeyColor).toEqual(0xffff0000);
+    expect(options.color).toEqual(0xff0000ff);
 
     options.someKeyColor = 'yellow';
     OptionsProcessor.processOptions(options);
 
   it('resolve image sources with name/ending with icon', () => {
     options.icon = 'require("https://wix.github.io/react-native-navigation/_images/logo.png");';
+    options.image = 'require("https://wix.github.io/react-native-navigation/_images/logo.png");';
+    options.myImage = 'require("https://wix.github.io/react-native-navigation/_images/logo.png");';
     options.topBar = {
       myIcon: 'require("https://wix.github.io/react-native-navigation/_images/logo.png");',
       myOtherValue: 'value'
     // and expect the value to be resovled, in this case it doesn't find anything and returns null
     expect(options.icon).toEqual(null);
     expect(options.topBar.myIcon).toEqual(null);
+    expect(options.image).toEqual(null);
+    expect(options.myImage).toEqual(null);
     expect(options.topBar.myOtherValue).toEqual('value');
   });
 

lib/src/commands/OptionsProcessor.ts

 export class OptionsProcessor {
   static processOptions(options: any) {
     _.forEach(options, (value, key) => {
-      if (value) {
-        if (_.endsWith(key, 'Color')) {
-          options[key] = processColor(value);
-        }
-        if (_.isEqual(key, 'icon') || _.endsWith(key, 'Icon') || _.endsWith(key, 'Image')) {
-          options[key] = resolveAssetSource(options[key]);
-        }
-        if (_.isObject(value) || _.isArray(value)) {
-          OptionsProcessor.processOptions(value);
-        }
+      if (!value) return
+
+      if (_.isEqual(key, 'color') || _.endsWith(key, 'Color')) {
+        options[key] = processColor(value);
+      }
+      if (_.isEqual(key, 'icon') || _.isEqual(key, 'image') || _.endsWith(key, 'Icon') || _.endsWith(key, 'Image')) {
+        options[key] = resolveAssetSource(options[key]);
+      }
+      if (_.isObject(value) || _.isArray(value)) {
+        OptionsProcessor.processOptions(value);
       }
     });
   }

lib/src/commands/values/LayoutNode.test.ts

+import { LayoutNode } from './LayoutNode';
+
+describe('LayoutNode', () => {
+  it('value type', () => {
+    
+  });
+});

lib/src/commands/values/LayoutNode.ts

+import { LayoutTypes } from "./LayoutTypes";
+
+export interface LayoutNode {
+  type: LayoutTypes
+}

lib/src/commands/values/LayoutType.test.ts

+import { LayoutType } from './LayoutType';
+
+describe('LayoutType', () => {
+  it('is an enum', () => {
+    expect(LayoutType.Component).toEqual('Component');
+    expect(LayoutType.Stack).toEqual('Stack');
+  });
+
+  it('valueOf dynamic string value', () => {
+    const name = 'Stack';
+    expect(LayoutType[name]).toEqual(LayoutType.Stack);
+    expect(LayoutType['asdasd']).toEqual(undefined);
+    expect(LayoutType.isValid('asdasd')).toBe(false);
+    expect(LayoutType.isValid('TopTabs')).toBe(true);
+    expect(LayoutType.isValid('isValid')).toBe(false);
+  });
+});
+
+// Component: 'Component',
+// Stack: 'Stack',
+// BottomTabs: 'BottomTabs',
+// SideMenuRoot: 'SideMenuRoot',
+// SideMenuCenter: 'SideMenuCenter',
+// SideMenuLeft: 'SideMenuLeft',
+// SideMenuRight: 'SideMenuRight',
+// TopTabs: 'TopTabs',

lib/src/commands/LayoutTypes.ts → lib/src/commands/values/LayoutType.ts

-export const enum LayoutTypes {
+import * as _ from 'lodash';
+
+export const enum LayoutType {
   Component = 'Component',
   Stack = 'Stack',
   BottomTabs = 'BottomTabs',
   SideMenuRight = 'SideMenuRight',
   TopTabs = 'TopTabs'
 };
+
+export function isValid(name: string) {
+  return _.keys(LayoutType);
+}

lib/src/commands/values/LayoutTypes.test.ts

+import { LayoutTypes } from './LayoutTypes';
+
+describe('LayoutTypes', () => {
+  it('enum isValid', () => {
+    expect(LayoutTypes.isValid('')).toBe(false);
+    expect(LayoutTypes.isValid('unknown type')).toBe(false);
+    expect(LayoutTypes.isValid('Component')).toBe(true);
+    expect(LayoutTypes.isValid('Stack')).toBe(true);
+    expect(LayoutTypes.isValid('Stack ')).toBe(false);
+  });
+});

lib/src/commands/values/LayoutTypes.ts

+export class LayoutTypes {
+  private static validTypes = [
+    'Component',
+    'Stack',
+    'BottomTabs',
+    'SideMenuRoot',
+    'SideMenuCenter',
+    'SideMenuLeft',
+    'SideMenuRight',
+    'TopTabs'];
+
+  public static isValid(type: string) {
+    return this.validTypes.includes(type);
+  }
+}

lib/src/commands/values/Options.test.ts

+import { Options } from "./Options";
+
+describe('Options', () => {
+  it('valueType', () => {
+  });
+});

lib/src/commands/values/Options.ts

+export interface Options {
+
+}