@omnia/fx-models 8.0.5-vnext → 8.0.6-dev-dev

package/internal-do-not-import-from-here/shared/models/theming/SharedBlueprintMethods.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpacingValueFromBlueprint = void 0;
+const SpacingSetting_1 = require("./SpacingSetting");
+function getSpacingValueFromBlueprint(spacingValue, blueprint) {
+    if (!spacingValue) {
+        return 0;
+    }
+    let negative = false;
+    let result = spacingValue;
+    if (isNaN(spacingValue) && blueprint?.definition) {
+        if (spacingValue.startsWith("-")) {
+            negative = true;
+        }
+        spacingValue = spacingValue.replace("-", "");
+        if (spacingValue === SpacingSetting_1.SpacingTypes.xs) {
+            result = blueprint.definition.xs;
+        }
+        else if (spacingValue === SpacingSetting_1.SpacingTypes.s) {
+            result = blueprint.definition.s;
+        }
+        else if (spacingValue === SpacingSetting_1.SpacingTypes.m) {
+            result = blueprint.definition.m;
+        }
+        else if (spacingValue === SpacingSetting_1.SpacingTypes.l) {
+            result = blueprint.definition.l;
+        }
+        else if (spacingValue === SpacingSetting_1.SpacingTypes.xl) {
+            result = blueprint.definition.xl;
+        }
+        else {
+            result = 0;
+        }
+    }
+    return negative ? -result : result;
+}
+exports.getSpacingValueFromBlueprint = getSpacingValueFromBlueprint;

package/internal-do-not-import-from-here/shared/models/theming/SharedColorMethods.d.ts

@@ -0,0 +1 @@
+export declare function setColorOpacity(color: any, opacity: any): any;

package/internal-do-not-import-from-here/shared/models/theming/SharedColorMethods.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setColorOpacity = void 0;
+function setColorOpacity(color, opacity) {
+    function getRGBValues(color) {
+        const tmpColor = color.replace("rgba", "rgb");
+        return tmpColor.substring(4, tmpColor.length - 1)
+            .replace(/ /g, "")
+            .split(",");
+    }
+    function getRGBValuesFromHex(color) {
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(color);
+        if (result) {
+            return [
+                parseInt(result[1], 16),
+                parseInt(result[2], 16),
+                parseInt(result[3], 16)
+            ];
+        }
+    }
+    function isRGBColor(color) {
+        if (!color) {
+            return null;
+        }
+        if (color.indexOf("rgb") > -1) {
+            return true;
+        }
+        if (color.indexOf("rgba") > -1) {
+            return true;
+        }
+        return false;
+    }
+    let rgb = null;
+    if (!isRGBColor(color)) {
+        rgb = getRGBValuesFromHex(color);
+    }
+    else {
+        rgb = getRGBValues(color);
+    }
+    if (rgb) {
+        return `rgba(${rgb[0]},${rgb[1]},${rgb[2]},${opacity})`;
+    }
+    return color;
+}
+exports.setColorOpacity = setColorOpacity;

package/internal-do-not-import-from-here/shared/models/theming/SpacingSetting.d.ts

@@ -0,0 +1,23 @@
+import { Guid } from "../Guid";
+export interface SpacingSettings {
+    top: number | SpacingType;
+    right: number | SpacingType;
+    bottom: number | SpacingType;
+    left: number | SpacingType;
+}
+export interface SpacingDefinition {
+    id: Guid;
+    xs: number;
+    s: number;
+    m: number;
+    l: number;
+    xl: number;
+}
+export type SpacingType = "xs" | "s" | "m" | "l" | "xl";
+export declare enum SpacingTypes {
+    xs = "xs",
+    s = "s",
+    m = "m",
+    l = "l",
+    xl = "xl"
+}

package/internal-do-not-import-from-here/shared/models/theming/SpacingSetting.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpacingTypes = void 0;
+var SpacingTypes;
+(function (SpacingTypes) {
+    SpacingTypes["xs"] = "xs";
+    SpacingTypes["s"] = "s";
+    SpacingTypes["m"] = "m";
+    SpacingTypes["l"] = "l";
+    SpacingTypes["xl"] = "xl";
+})(SpacingTypes = exports.SpacingTypes || (exports.SpacingTypes = {}));

package/internal-do-not-import-from-here/shared/models/theming/ThemeDefinitionV2.d.ts

@@ -1,12 +1,20 @@
 import { Guid } from "../Guid";
-import { BlueprintDefinition } from "./BlueprintDefinition";
-import { TypographyDefinition } from "./TypographyDefinition";
+import { BluePrintDefinitions } from "./BlueprintDefinition";
+export interface ColorTypeResult<resultType> {
+    base: resultType;
+    baseTone: resultType;
+    onBase: resultType;
+    onBaseTone: resultType;
+    container: resultType;
+    containerTone: resultType;
+    onContainer: resultType;
+    onContainerTone: resultType;
+    colorType: (colorType: string) => resultType;
+}
 export interface ColorDefinition {
     dark: boolean;
     color: string;
     colorToned: string;
-    colorStyles: ColorStyles;
-    colorTonedStyles: ColorStyles;
 }
 export interface ColorStyles {
     background: object | string;
@@ -20,14 +28,7 @@ export interface ColorSchema {
     container: ColorDefinition;
     onContainer: ColorDefinition;
 }
-export interface ColorGroup {
-    dark: ColorSchema;
-    light: ColorSchema;
-}
-export interface ThemeDefinitionV2 {
-    id: Guid;
-    name: string;
-    dark: boolean;
+export interface ColorSchemas {
     primary: ColorSchema;
     secondary: ColorSchema;
     accent1: ColorSchema;
@@ -37,27 +38,45 @@ export interface ThemeDefinitionV2 {
     background: ColorSchema;
     error: ColorSchema;
     info: ColorSchema;
-    typography: TypographyDefinition;
-    blueprint: BlueprintDefinition;
-}
-export declare const ColorSchemaTypes: {
-    primary: string;
-    secondary: string;
-    accent1: string;
-    accent2: string;
-    accent3: string;
-    neutral: string;
-    background: string;
-    error: string;
-    info: string;
-};
-export declare const ColorTypes: {
-    base: string;
-    baseTone: string;
-    onBase: string;
-    onBaseTone: string;
-    container: string;
-    containerTone: string;
-    onContainer: string;
-    onContainerTone: string;
-};
+}
+export interface ColorGroup {
+    dark: ColorSchema;
+    light: ColorSchema;
+}
+export interface ThemeDefinitionV2 {
+    id: Guid;
+    name: string;
+    dark: boolean;
+    colors: ColorSchemas;
+    blueprints: BluePrintDefinitions;
+}
+export type ColorSchemaType = keyof typeof ColorSchemaTypes;
+export declare enum ColorSchemaTypes {
+    primary = "primary",
+    secondary = "secondary",
+    accent1 = "accent1",
+    accent2 = "accent2",
+    accent3 = "accent3",
+    neutral = "neutral",
+    background = "background",
+    error = "error",
+    info = "info"
+}
+export type BlueprintType = keyof typeof BlueprintTypes;
+export declare enum BlueprintTypes {
+    default = "default",
+    variant1 = "variant1",
+    variant2 = "variant2",
+    variant3 = "variant3"
+}
+export type ColorType = keyof typeof ColorTypes;
+export declare enum ColorTypes {
+    base = "base",
+    onBase = "onBase",
+    container = "container",
+    onContainer = "onContainer"
+}
+export interface ColorGradient {
+    color: string;
+    stop?: number;
+}

package/internal-do-not-import-from-here/shared/models/theming/ThemeDefinitionV2.js

@@ -1,24 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ColorTypes = exports.ColorSchemaTypes = void 0;
-exports.ColorSchemaTypes = {
-    primary: "primary",
-    secondary: "secondary",
-    accent1: "accent1",
-    accent2: "accent2",
-    accent3: "accent3",
-    neutral: "neutral",
-    background: "background",
-    error: "error",
-    info: "info",
-};
-exports.ColorTypes = {
-    base: "base",
-    baseTone: "baseTone",
-    onBase: "onBase",
-    onBaseTone: "onBaseTone",
-    container: "container",
-    containerTone: "containerTone",
-    onContainer: "onContainer",
-    onContainerTone: "onContainerTone",
-};
+exports.ColorTypes = exports.BlueprintTypes = exports.ColorSchemaTypes = void 0;
+var ColorSchemaTypes;
+(function (ColorSchemaTypes) {
+    ColorSchemaTypes["primary"] = "primary";
+    ColorSchemaTypes["secondary"] = "secondary";
+    ColorSchemaTypes["accent1"] = "accent1";
+    ColorSchemaTypes["accent2"] = "accent2";
+    ColorSchemaTypes["accent3"] = "accent3";
+    ColorSchemaTypes["neutral"] = "neutral";
+    ColorSchemaTypes["background"] = "background";
+    ColorSchemaTypes["error"] = "error";
+    ColorSchemaTypes["info"] = "info";
+})(ColorSchemaTypes = exports.ColorSchemaTypes || (exports.ColorSchemaTypes = {}));
+var BlueprintTypes;
+(function (BlueprintTypes) {
+    BlueprintTypes["default"] = "default";
+    BlueprintTypes["variant1"] = "variant1";
+    BlueprintTypes["variant2"] = "variant2";
+    BlueprintTypes["variant3"] = "variant3";
+})(BlueprintTypes = exports.BlueprintTypes || (exports.BlueprintTypes = {}));
+var ColorTypes;
+(function (ColorTypes) {
+    ColorTypes["base"] = "base";
+    ColorTypes["onBase"] = "onBase";
+    ColorTypes["container"] = "container";
+    ColorTypes["onContainer"] = "onContainer";
+})(ColorTypes = exports.ColorTypes || (exports.ColorTypes = {}));

package/internal-do-not-import-from-here/shared/models/theming/TypographyDefinition.d.ts

@@ -1,30 +1,49 @@
 import { Guid } from "../Guid";
 export interface TypographyDefinition {
     id: Guid;
-    h1: TypographyType;
-    h2: TypographyType;
-    h3: TypographyType;
-    text: TypographyType;
-    caption: TypographyType;
-    link: TypographyType;
+    title: {
+        xl: TypographyTypeDefinition;
+        l: TypographyTypeDefinition;
+        m: TypographyTypeDefinition;
+        s: TypographyTypeDefinition;
+        xs: TypographyTypeDefinition;
+    };
+    text: {
+        l: TypographyTypeDefinition;
+        m: TypographyTypeDefinition;
+        s: TypographyTypeDefinition;
+        xs: TypographyTypeDefinition;
+    };
+    navigation: {
+        l: TypographyTypeDefinition;
+        m: TypographyTypeDefinition;
+    };
+    link: {
+        m: TypographyTypeDefinition;
+    };
 }
-export interface TypographyType {
+export interface TypographyTypeDefinition {
     decoration?: string;
     large: TypographyTypeBreakPoint;
     medium?: TypographyTypeBreakPoint;
     small?: TypographyTypeBreakPoint;
-    style: object | string;
 }
 export interface TypographyTypeBreakPoint {
     weight: number;
     size: number;
     lineHeight: number;
 }
-export declare const TypographyTypes: {
-    h1: string;
-    h2: string;
-    h3: string;
-    text: string;
-    caption: string;
-    link: string;
-};
+export type TypographyType = keyof typeof TypographyTypes;
+export declare enum TypographyTypes {
+    title = "title",
+    text = "text",
+    navigation = "navigation"
+}
+export type TypographySize = keyof typeof TypographySizes;
+export declare enum TypographySizes {
+    xl = "xl",
+    l = "l",
+    m = "m",
+    s = "s",
+    xs = "xs"
+}

package/internal-do-not-import-from-here/shared/models/theming/TypographyDefinition.js

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypographyTypes = void 0;
-exports.TypographyTypes = {
-    h1: "h1",
-    h2: "h2",
-    h3: "h3",
-    text: "text",
-    caption: "caption",
-    link: "link",
-};
+exports.TypographySizes = exports.TypographyTypes = void 0;
+var TypographyTypes;
+(function (TypographyTypes) {
+    TypographyTypes["title"] = "title";
+    TypographyTypes["text"] = "text";
+    TypographyTypes["navigation"] = "navigation";
+})(TypographyTypes = exports.TypographyTypes || (exports.TypographyTypes = {}));
+var TypographySizes;
+(function (TypographySizes) {
+    TypographySizes["xl"] = "xl";
+    TypographySizes["l"] = "l";
+    TypographySizes["m"] = "m";
+    TypographySizes["s"] = "s";
+    TypographySizes["xs"] = "xs";
+})(TypographySizes = exports.TypographySizes || (exports.TypographySizes = {}));

package/internal-do-not-import-from-here/shared/models/theming/UseThemeMethods.d.ts

@@ -0,0 +1,13 @@
+import { BlueprintType, BlueprintTypes, ColorDefinition, ColorSchema, ColorSchemaType, ColorSchemaTypes, ColorType, ColorTypes } from "./ThemeDefinitionV2";
+import { TypographySize, TypographySizes, TypographyType, TypographyTypeDefinition, TypographyTypes } from "./TypographyDefinition";
+import { BlueprintDefinition } from "./BlueprintDefinition";
+export declare function useThemeMethods(getThemeDefinition: () => any): {
+    colorSchema: (colorSchemaType: ColorSchemaTypes | ColorSchemaType) => ColorSchema;
+    blueprint: (blueprintType: BlueprintTypes | BlueprintType) => BlueprintDefinition;
+    typography: (blueprintType: BlueprintTypes | BlueprintType, typographyType: TypographyTypes | TypographyType, size: TypographySize | TypographySizes) => TypographyTypeDefinition;
+    color: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType) => string;
+    colorDefinition: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType) => ColorDefinition;
+    complementaryColorType: (colorType: ColorTypes | ColorType) => ColorTypes;
+    complementaryColor: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType) => string;
+    complementaryColorDefinition: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType) => ColorDefinition;
+};

package/internal-do-not-import-from-here/shared/models/theming/UseThemeMethods.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useThemeMethods = void 0;
+//import { ThemeDefinitionInstance } from "@omnia/fx/ux";
+const ThemeDefinitionV2_1 = require("./ThemeDefinitionV2");
+const TypographyDefinition_1 = require("./TypographyDefinition");
+// temp change ThemeDefinitionInstance to any because fx/shared can't reference higher level fx/ux
+function useThemeMethods(getThemeDefinition) {
+    function colorSchema(colorSchemaType) {
+        if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.primary) {
+            return getThemeDefinition().colors.primary;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.secondary) {
+            return getThemeDefinition().colors.secondary;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.accent1) {
+            return getThemeDefinition().colors.accent1;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.accent2) {
+            return getThemeDefinition().colors.accent2;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.accent3) {
+            return getThemeDefinition().colors.accent3;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.background) {
+            return getThemeDefinition().colors.background;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.neutral) {
+            return getThemeDefinition().colors.neutral;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.error) {
+            return getThemeDefinition().colors.error;
+        }
+        return getThemeDefinition().colors.background;
+    }
+    function blueprint(blueprintType) {
+        if (blueprintType === ThemeDefinitionV2_1.BlueprintTypes.default) {
+            return getThemeDefinition().blueprints.default;
+        }
+        else if (blueprintType === ThemeDefinitionV2_1.BlueprintTypes.variant1) {
+            return getThemeDefinition().blueprints.variant1;
+        }
+        else if (blueprintType === ThemeDefinitionV2_1.BlueprintTypes.variant2) {
+            return getThemeDefinition().blueprints.variant2;
+        }
+        else if (blueprintType === ThemeDefinitionV2_1.BlueprintTypes.variant3) {
+            return getThemeDefinition().blueprints.variant3;
+        }
+        return getThemeDefinition().blueprints.default;
+    }
+    function typography(blueprintType, typographyType, size) {
+        const typographyBlueprint = getThemeDefinition().blueprints[blueprintType].definitions.find(d => d.type === "typography");
+        if (typographyType === TypographyDefinition_1.TypographyTypes.text) {
+            return typographyBlueprint.definition.text[size];
+        }
+        else if (typographyType === TypographyDefinition_1.TypographyTypes.title) {
+            return typographyBlueprint.definition.title[size];
+        }
+        else if (typographyType === TypographyDefinition_1.TypographyTypes.navigation) {
+            return typographyBlueprint.definition[size];
+        }
+    }
+    function color(colorSchemaType, colorType) {
+        const mappedColorSchema = colorSchema(colorSchemaType);
+        if (colorType === ThemeDefinitionV2_1.ColorTypes.base) {
+            return mappedColorSchema.base.color;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onBase) {
+            return mappedColorSchema.onBase.color;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.container) {
+            return mappedColorSchema.container.color;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onContainer) {
+            return mappedColorSchema.onContainer.color;
+        }
+        return colorType;
+    }
+    function colorDefinition(colorSchemaType, colorType) {
+        const mappedColorSchema = colorSchema(colorSchemaType);
+        if (colorType === ThemeDefinitionV2_1.ColorTypes.base) {
+            return mappedColorSchema.base;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onBase) {
+            return mappedColorSchema.onBase;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.container) {
+            return mappedColorSchema.container;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onContainer) {
+            return mappedColorSchema.onContainer;
+        }
+        return mappedColorSchema.base;
+    }
+    function complementaryColorType(colorType) {
+        if (colorType === ThemeDefinitionV2_1.ColorTypes.base) {
+            return ThemeDefinitionV2_1.ColorTypes.onBase;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onBase) {
+            return ThemeDefinitionV2_1.ColorTypes.base;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.container) {
+            return ThemeDefinitionV2_1.ColorTypes.onContainer;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onContainer) {
+            return ThemeDefinitionV2_1.ColorTypes.container;
+        }
+        return colorType;
+    }
+    function complementaryColor(colorSchemaType, colorType) {
+        const matchingColorType = complementaryColorType(colorType);
+        return color(colorSchemaType, matchingColorType);
+    }
+    function complementaryColorDefinition(colorSchemaType, colorType) {
+        const matchingColorType = complementaryColorType(colorType);
+        return colorDefinition(colorSchemaType, matchingColorType);
+    }
+    return {
+        colorSchema,
+        blueprint,
+        typography,
+        color,
+        colorDefinition,
+        complementaryColorType,
+        complementaryColor,
+        complementaryColorDefinition,
+    };
+}
+exports.useThemeMethods = useThemeMethods;

package/internal-do-not-import-from-here/shared/models/theming/index.d.ts

@@ -1,3 +1,8 @@
 export * from "./ThemeDefinitionV2";
 export * from "./TypographyDefinition";
 export * from "./OmniaThemes";
+export * from "./UseThemeMethods";
+export * from "./BlueprintDefinition";
+export * from "./SpacingSetting";
+export * from "./SharedBlueprintMethods";
+export * from "./SharedColorMethods";

package/internal-do-not-import-from-here/shared/models/theming/index.js

@@ -4,3 +4,8 @@ const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./ThemeDefinitionV2"), exports);
 tslib_1.__exportStar(require("./TypographyDefinition"), exports);
 tslib_1.__exportStar(require("./OmniaThemes"), exports);
+tslib_1.__exportStar(require("./UseThemeMethods"), exports);
+tslib_1.__exportStar(require("./BlueprintDefinition"), exports);
+tslib_1.__exportStar(require("./SpacingSetting"), exports);
+tslib_1.__exportStar(require("./SharedBlueprintMethods"), exports);
+tslib_1.__exportStar(require("./SharedColorMethods"), exports);

package/internal-do-not-import-from-here/velcron/core/models/ActionHooks.d.ts

@@ -0,0 +1,12 @@
+export interface VelcronActionHooks<TBefore = any, TAfter = any> {
+    beforeHandler?: (args: TBefore) => TBefore;
+    afterHandler?: (args: TBefore) => TAfter;
+}
+export interface HttpGetBeforeActionHookArgs {
+    url: string;
+    requestInit: RequestInit;
+}
+export interface HttpGetAfterActionHookArgs {
+    json: string;
+    response: Response;
+}

package/internal-do-not-import-from-here/velcron/core/models/ActionHooks.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/internal-do-not-import-from-here/velcron/core/models/Enums.d.ts

@@ -16,31 +16,22 @@ export declare enum VelcronActionTypes {
 export declare enum VelcronIconTypes {
     fontAwesome = "fa"
 }
+export declare enum VelcronViewDirections {
+    row = "row",
+    column = "column",
+    rowReverse = "row-reverse",
+    columnRevers = "column-reverse"
+}
 export declare enum VelcronHorizontalAlignments {
     left = "left",
     center = "center",
     right = "right"
 }
-export declare enum VerticalAlignments {
+export declare enum VelcronVerticalAlignments {
     top = "top",
     center = "center",
     bottom = "bottom"
 }
-export declare enum VelcronDescriptorTypes {
-    component = 0,
-    subComponent = 1,
-    appData = 2,
-    dataMember = 3
-}
-export declare enum VelcronComponentPropertyEditors {
-    text = 0,
-    colorSchemaPicker = 1,
-    slider = 2,
-    colorPicker = 3,
-    typographyPicker = 4,
-    ratioPicker = 5,
-    booleanPicker = 6
-}
 export declare enum VelcronDataTypes {
     unknown = "unknown",
     object = "object",

package/internal-do-not-import-from-here/velcron/core/models/Enums.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VelcronDataTypes = exports.VelcronComponentPropertyEditors = exports.VelcronDescriptorTypes = exports.VerticalAlignments = exports.VelcronHorizontalAlignments = exports.VelcronIconTypes = exports.VelcronActionTypes = exports.AssignOperators = void 0;
+exports.VelcronDataTypes = exports.VelcronVerticalAlignments = exports.VelcronHorizontalAlignments = exports.VelcronViewDirections = exports.VelcronIconTypes = exports.VelcronActionTypes = exports.AssignOperators = void 0;
 var AssignOperators;
 (function (AssignOperators) {
     AssignOperators["equals"] = "=";
@@ -22,35 +22,25 @@ var VelcronIconTypes;
 (function (VelcronIconTypes) {
     VelcronIconTypes["fontAwesome"] = "fa";
 })(VelcronIconTypes = exports.VelcronIconTypes || (exports.VelcronIconTypes = {}));
+var VelcronViewDirections;
+(function (VelcronViewDirections) {
+    VelcronViewDirections["row"] = "row";
+    VelcronViewDirections["column"] = "column";
+    VelcronViewDirections["rowReverse"] = "row-reverse";
+    VelcronViewDirections["columnRevers"] = "column-reverse";
+})(VelcronViewDirections = exports.VelcronViewDirections || (exports.VelcronViewDirections = {}));
 var VelcronHorizontalAlignments;
 (function (VelcronHorizontalAlignments) {
     VelcronHorizontalAlignments["left"] = "left";
     VelcronHorizontalAlignments["center"] = "center";
     VelcronHorizontalAlignments["right"] = "right";
 })(VelcronHorizontalAlignments = exports.VelcronHorizontalAlignments || (exports.VelcronHorizontalAlignments = {}));
-var VerticalAlignments;
-(function (VerticalAlignments) {
-    VerticalAlignments["top"] = "top";
-    VerticalAlignments["center"] = "center";
-    VerticalAlignments["bottom"] = "bottom";
-})(VerticalAlignments = exports.VerticalAlignments || (exports.VerticalAlignments = {}));
-var VelcronDescriptorTypes;
-(function (VelcronDescriptorTypes) {
-    VelcronDescriptorTypes[VelcronDescriptorTypes["component"] = 0] = "component";
-    VelcronDescriptorTypes[VelcronDescriptorTypes["subComponent"] = 1] = "subComponent";
-    VelcronDescriptorTypes[VelcronDescriptorTypes["appData"] = 2] = "appData";
-    VelcronDescriptorTypes[VelcronDescriptorTypes["dataMember"] = 3] = "dataMember";
-})(VelcronDescriptorTypes = exports.VelcronDescriptorTypes || (exports.VelcronDescriptorTypes = {}));
-var VelcronComponentPropertyEditors;
-(function (VelcronComponentPropertyEditors) {
-    VelcronComponentPropertyEditors[VelcronComponentPropertyEditors["text"] = 0] = "text";
-    VelcronComponentPropertyEditors[VelcronComponentPropertyEditors["colorSchemaPicker"] = 1] = "colorSchemaPicker";
-    VelcronComponentPropertyEditors[VelcronComponentPropertyEditors["slider"] = 2] = "slider";
-    VelcronComponentPropertyEditors[VelcronComponentPropertyEditors["colorPicker"] = 3] = "colorPicker";
-    VelcronComponentPropertyEditors[VelcronComponentPropertyEditors["typographyPicker"] = 4] = "typographyPicker";
-    VelcronComponentPropertyEditors[VelcronComponentPropertyEditors["ratioPicker"] = 5] = "ratioPicker";
-    VelcronComponentPropertyEditors[VelcronComponentPropertyEditors["booleanPicker"] = 6] = "booleanPicker";
-})(VelcronComponentPropertyEditors = exports.VelcronComponentPropertyEditors || (exports.VelcronComponentPropertyEditors = {}));
+var VelcronVerticalAlignments;
+(function (VelcronVerticalAlignments) {
+    VelcronVerticalAlignments["top"] = "top";
+    VelcronVerticalAlignments["center"] = "center";
+    VelcronVerticalAlignments["bottom"] = "bottom";
+})(VelcronVerticalAlignments = exports.VelcronVerticalAlignments || (exports.VelcronVerticalAlignments = {}));
 var VelcronDataTypes;
 (function (VelcronDataTypes) {
     //Unknown = null