@omnia/velcron 6.100.8-dev

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useThemeMethods = void 0;
+const ThemeDefinitionV2_1 = require("./ThemeDefinitionV2");
+const TypographyDefinition_1 = require("./TypographyDefinition");
+const useThemeMethods = (themedefinition) => {
+    const colorSchema = (colorSchemaType) => {
+        if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.primary) {
+            return themedefinition.primary;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.secondary) {
+            return themedefinition.secondary;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.accent1) {
+            return themedefinition.accent1;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.accent2) {
+            return themedefinition.accent2;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.accent3) {
+            return themedefinition.accent3;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.background) {
+            return themedefinition.background;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.neutral) {
+            return themedefinition.neutral;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.error) {
+            return themedefinition.error;
+        }
+        return themedefinition.background;
+    };
+    const typography = (typographyType) => {
+        if (typographyType === TypographyDefinition_1.TypographyTypes.h1) {
+            return themedefinition.typography.h1;
+        }
+        else if (typographyType === TypographyDefinition_1.TypographyTypes.h2) {
+            return themedefinition.typography.h2;
+        }
+        else if (typographyType === TypographyDefinition_1.TypographyTypes.h3) {
+            return themedefinition.typography.h3;
+        }
+        else if (typographyType === TypographyDefinition_1.TypographyTypes.caption) {
+            return themedefinition.typography.caption;
+        }
+        else if (typographyType === TypographyDefinition_1.TypographyTypes.link) {
+            return themedefinition.typography.link;
+        }
+        else if (typographyType === TypographyDefinition_1.TypographyTypes.text) {
+            return themedefinition.typography.text;
+        }
+        return themedefinition.typography.text;
+    };
+    const color = (colorSchemaType, colorType) => {
+        const mappedColorSchema = colorSchema(colorSchemaType);
+        if (colorType === ThemeDefinitionV2_1.ColorTypes.base) {
+            return mappedColorSchema.base.color;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.baseTone) {
+            return mappedColorSchema.base.colorToned;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onBase) {
+            return mappedColorSchema.onBase.color;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onBaseTone) {
+            return mappedColorSchema.onBase.colorToned;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.container) {
+            return mappedColorSchema.container.color;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.containerTone) {
+            return mappedColorSchema.container.colorToned;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onContainer) {
+            return mappedColorSchema.onContainer.color;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onContainerTone) {
+            return mappedColorSchema.onContainer.colorToned;
+        }
+        return colorType;
+    };
+    const colorDefinition = (colorSchemaType, colorType) => {
+        const mappedColorSchema = colorSchema(colorSchemaType);
+        if (colorType === ThemeDefinitionV2_1.ColorTypes.base
+            || colorType === ThemeDefinitionV2_1.ColorTypes.baseTone) {
+            return mappedColorSchema.base;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onBase
+            ||
+                colorType === ThemeDefinitionV2_1.ColorTypes.onBaseTone) {
+            return mappedColorSchema.onBase;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.container
+            ||
+                colorType === ThemeDefinitionV2_1.ColorTypes.containerTone) {
+            return mappedColorSchema.container;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onContainer
+            ||
+                colorType === ThemeDefinitionV2_1.ColorTypes.onContainerTone) {
+            return mappedColorSchema.onContainer;
+        }
+        return mappedColorSchema.base;
+    };
+    const complementaryColorType = (colorType) => {
+        if (colorType === ThemeDefinitionV2_1.ColorTypes.base
+            || colorType === ThemeDefinitionV2_1.ColorTypes.baseTone) {
+            return ThemeDefinitionV2_1.ColorTypes.onBase;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onBase
+            || colorType === ThemeDefinitionV2_1.ColorTypes.onBaseTone) {
+            return ThemeDefinitionV2_1.ColorTypes.base;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.container
+            || colorType === ThemeDefinitionV2_1.ColorTypes.containerTone) {
+            return ThemeDefinitionV2_1.ColorTypes.onContainer;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onContainer
+            || colorType === ThemeDefinitionV2_1.ColorTypes.onContainerTone) {
+            return ThemeDefinitionV2_1.ColorTypes.container;
+        }
+        return colorType;
+    };
+    const complementaryColor = (colorSchemaType, colorType) => {
+        const matchingColorType = complementaryColorType(colorType);
+        return color(colorSchemaType, matchingColorType);
+    };
+    const complementaryColorDefinition = (colorSchemaType, colorType) => {
+        const matchingColorType = complementaryColorType(colorType);
+        return colorDefinition(colorSchemaType, matchingColorType);
+    };
+    return {
+        colorSchema,
+        typography,
+        color,
+        colorDefinition,
+        complementaryColorType,
+        complementaryColor,
+        complementaryColorDefinition
+    };
+};
+exports.useThemeMethods = useThemeMethods;

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

@@ -0,0 +1,29 @@
+import { Guid } from "../Guid";
+export interface TypographyDefinition {
+    id: Guid;
+    h1: TypographyType;
+    h2: TypographyType;
+    h3: TypographyType;
+    text: TypographyType;
+    caption: TypographyType;
+    link: TypographyType;
+}
+export interface TypographyType {
+    decoration?: string;
+    large: TypographyTypeBreakPoint;
+    medium?: TypographyTypeBreakPoint;
+    small?: TypographyTypeBreakPoint;
+}
+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;
+};

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

@@ -0,0 +1,11 @@
+"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",
+};

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

@@ -0,0 +1,4 @@
+export * from "./ThemeDefinitionV2";
+export * from "./TypographyDefinition";
+export * from "./OmniaThemes";
+export * from "./ThemeMethods";

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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("./ThemeMethods"), exports);

package/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/models/ActionHooks.js

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

package/models/Enums.d.ts

@@ -0,0 +1,53 @@
+export declare enum AssignOperators {
+    equals = "=",
+    plusEquals = "+=",
+    equalsPlus = "=+",
+    equalsQuestion = "=?",
+    plusPlus = "++",
+    minusMinus = "--",
+    equalsExclamation = "=!"
+}
+export declare enum VelcronActionTypes {
+    getOrSetValue = 0,
+    promise = 1,
+    condition = 2,
+    returnsValue = 3
+}
+export declare enum VelcronIconTypes {
+    fontAwesome = "fa"
+}
+export declare enum VelcronHorizontalAlignments {
+    left = "left",
+    center = "center",
+    right = "right"
+}
+export declare enum VerticalAlignments {
+    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",
+    text = "text",
+    number = "number",
+    boolean = "boolean",
+    array = "array",
+    componentArray = "componentArray",
+    bind = "bind"
+}

package/models/Enums.js

@@ -0,0 +1,65 @@
+"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;
+var AssignOperators;
+(function (AssignOperators) {
+    AssignOperators["equals"] = "=";
+    AssignOperators["plusEquals"] = "+=";
+    AssignOperators["equalsPlus"] = "=+";
+    AssignOperators["equalsQuestion"] = "=?";
+    AssignOperators["plusPlus"] = "++";
+    AssignOperators["minusMinus"] = "--";
+    AssignOperators["equalsExclamation"] = "=!";
+})(AssignOperators = exports.AssignOperators || (exports.AssignOperators = {}));
+var VelcronActionTypes;
+(function (VelcronActionTypes) {
+    VelcronActionTypes[VelcronActionTypes["getOrSetValue"] = 0] = "getOrSetValue";
+    VelcronActionTypes[VelcronActionTypes["promise"] = 1] = "promise";
+    VelcronActionTypes[VelcronActionTypes["condition"] = 2] = "condition";
+    VelcronActionTypes[VelcronActionTypes["returnsValue"] = 3] = "returnsValue";
+})(VelcronActionTypes = exports.VelcronActionTypes || (exports.VelcronActionTypes = {}));
+var VelcronIconTypes;
+(function (VelcronIconTypes) {
+    VelcronIconTypes["fontAwesome"] = "fa";
+})(VelcronIconTypes = exports.VelcronIconTypes || (exports.VelcronIconTypes = {}));
+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 VelcronDataTypes;
+(function (VelcronDataTypes) {
+    //Unknown = null
+    VelcronDataTypes["unknown"] = "unknown";
+    VelcronDataTypes["object"] = "object";
+    VelcronDataTypes["text"] = "text";
+    VelcronDataTypes["number"] = "number";
+    VelcronDataTypes["boolean"] = "boolean";
+    VelcronDataTypes["array"] = "array";
+    VelcronDataTypes["componentArray"] = "componentArray";
+    VelcronDataTypes["bind"] = "bind";
+})(VelcronDataTypes = exports.VelcronDataTypes || (exports.VelcronDataTypes = {}));

package/models/VelcronDefinitions.d.ts

@@ -0,0 +1,265 @@
+import { VelcronComponentDescriptor } from "./VelcronDescriptors";
+import { VelcronEvent, VelcronOnChangedEvent, VelcronOnClosedEvent, VelcronOnCloseRequestedEvent, VelcronOnLoadEvent, VelcronOnPressEvent } from "./VelcronEvents";
+import { VelcroncomponentArrayType, VelcronPrimitiveType } from "./VelcronTypes";
+import { AssignOperators, VelcronHorizontalAlignments, VelcronIconTypes, VelcronActionTypes, VerticalAlignments } from "./Enums";
+import { ColorSchema, useVelcronThemingStore } from "..";
+export interface ResolvedComponentRenderer {
+    component: unknown;
+    definition: VelcronDefinition;
+    customComponent?: boolean;
+}
+export interface BuiltInComponentRenderers {
+    "View": unknown;
+    "Card": unknown;
+    "Text": unknown;
+    "Image": unknown;
+    "Button": unknown;
+    "TextInput": unknown;
+    "ProgressCircle": unknown;
+    "WebView": unknown;
+    "CustomComponent": unknown;
+    "Dialog": unknown;
+    "Icon": unknown;
+    "Chip": unknown;
+    "Slot": unknown;
+}
+export interface ColorSchemaReference {
+    name: string;
+    schema: string;
+}
+export type DynamicState = object;
+export interface OnItemRenderedHookResult {
+    cssClass: string;
+    containerRenderer?: VelcronContainerRenderer;
+}
+export interface VelcronRenderContext {
+    id?: string;
+    rootContext: DynamicState;
+    currentContext: DynamicState;
+    theming?: ReturnType<typeof useVelcronThemingStore>;
+    colorSchemaType?: string;
+    colorSchema?: ColorSchema;
+    actions?: {
+        [name: string]: [];
+    };
+    components?: Array<VelcronCustomComponentDefinition>;
+    properties?: {
+        [name: string]: VelcronPrimitiveType | VelcroncomponentArrayType;
+    };
+    computed?: {
+        [name: string]: [];
+    };
+    parent?: VelcronRenderContext;
+    hooks?: VelcronRenderContextHooks;
+    eventHandlers?: VelcronRenderContextEventHandlers;
+}
+export interface VelcronRenderContextEventHandlers {
+    receiving?: {
+        [name: string]: (...args: any[]) => void;
+    };
+    emitting?: <T>(emitter: (i: T) => T) => T;
+}
+export interface VelcronRenderContextHooks {
+    dialogVisibilityChanged?: ((visible: boolean) => void);
+    onItemSelected?: ((item: VelcronDefinition) => void);
+    onItemRendered?: ((item: VelcronDefinition) => OnItemRenderedHookResult);
+}
+export interface VelcronContainerRenderer {
+    definition: VelcronDefinition;
+    renderContext: VelcronRenderContext;
+    component: JSX.Element;
+}
+export interface VelcronAction extends VelcronRenderContext {
+    type: VelcronActionTypes;
+}
+export interface VelcronActionGetOrSetValue extends VelcronAction {
+    value?: unknown;
+    path: string;
+    id: string;
+    assignOperator?: AssignOperators;
+}
+export interface VelcronActionWithAutoAwait extends VelcronActionGetOrSetValue {
+    nowait: boolean;
+    action: string;
+}
+export interface VelcronActionWithCondition extends VelcronActionWithAutoAwait {
+    condition: string;
+    trueAction: VelcronAction;
+    falseAction: VelcronAction;
+}
+/**
+ * Velcron definition base
+ */
+export interface VelcronDefinitionBase {
+    /**
+     * The component type
+     */
+    type: string;
+    /**
+     * Custom friendly name of the definition
+     */
+    name?: string;
+    /**
+     * Used for render cache if not specified we auto set it.
+     */
+    key?: string;
+}
+export interface VelcronCustomThemeSettings {
+    colorSchema?: string;
+    color?: string;
+    opacity?: number;
+}
+export interface VelcronDefinition extends VelcronDefinitionBase {
+    body?: Array<VelcronDefinition>;
+    style?: VelcronStyling;
+    foreach?: string;
+    if?: string;
+    events?: VelcronEvent;
+}
+export interface VelcronStyling {
+    margin?: number;
+    marginTop?: number;
+    marginRight?: number;
+    marginBottom?: number;
+    marginLeft?: number;
+    padding?: number;
+    paddingTop?: number;
+    paddingRight?: number;
+    paddingBottom?: number;
+    paddingLeft?: number;
+    height?: number | string;
+    width?: number | string;
+}
+export interface VelcronCardStyling extends VelcronStyling {
+    elevation: number;
+}
+export interface VelcronSpacing {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface VelcronIcon {
+    type: VelcronIconTypes;
+    name: string;
+}
+export interface VelcronAppDefinition<TState extends DynamicState = DynamicState> extends VelcronDefinitionBase {
+    type: "Velcron";
+    body?: Array<VelcronDefinition>;
+    events?: VelcronOnLoadEvent & VelcronOnPressEvent;
+    actions?: {
+        [name: string]: [];
+    };
+    components?: Array<VelcronCustomComponentDefinition>;
+    state?: TState;
+    computed?: {
+        [name: string]: [];
+    };
+}
+export interface VelcronComponentDefinition extends VelcronDefinition {
+    type: string;
+    events: VelcronOnPressEvent;
+}
+/*** Built-in Components *********************************************************************/
+export interface VelcronViewDefinition extends VelcronDefinition, VelcronCustomThemeSettings {
+    type: "View";
+    events?: VelcronOnPressEvent;
+    column?: boolean;
+    body: Array<VelcronDefinition>;
+    columnStyle?: object;
+    horizontalAlignment?: VelcronHorizontalAlignments;
+    verticalAlignment?: VerticalAlignments;
+    grow?: number;
+    border?: VelcronBorder;
+    borderRadius?: VelcronDimensions;
+    width: string;
+}
+export interface VelcronCardDefinition extends VelcronDefinition, VelcronCustomThemeSettings {
+    type: "Card";
+    style?: VelcronCardStyling;
+    footer?: Array<VelcronDefinition>;
+    events?: VelcronOnPressEvent;
+}
+export interface VelcronTextDefinition extends VelcronDefinition {
+    type: "Text";
+    text: string;
+    color?: string;
+    lineClamp: number;
+    noWrap: boolean;
+    typography?: string;
+    events?: VelcronOnPressEvent;
+}
+export declare enum VelcronImageRatios {
+    square = 1,
+    landscape = 2
+}
+export interface VelcronImageDefinition extends VelcronDefinition {
+    type: "Image";
+    source: string;
+    ratio: VelcronImageRatios;
+    borderRadius?: VelcronDimensions;
+    events?: VelcronOnPressEvent;
+}
+export interface VelcronButtonDefinition extends VelcronDefinition {
+    type: "Button";
+    text: string;
+    color: string;
+    icon?: VelcronIcon;
+    disabled?: boolean;
+    events?: VelcronOnPressEvent;
+}
+export interface VelcronTextInputDefinition extends VelcronDefinition {
+    type: "TextInput";
+    label?: string;
+    bind: string;
+    initialValue?: string;
+    events: VelcronOnChangedEvent;
+}
+export interface VelcronProgressCircleDefinition extends VelcronDefinition {
+    type: "ProgressCircle";
+    events?: VelcronOnPressEvent;
+}
+export interface VelcronWebViewDefinition extends VelcronDefinition {
+    type: "WebView";
+    source: string;
+}
+export interface VelcronDialogDefinition extends VelcronDefinition {
+    type: "Dialog";
+    title: string;
+    visible: string;
+    events?: VelcronOnCloseRequestedEvent & VelcronOnClosedEvent;
+}
+export interface VelcronIconDefinition extends VelcronDefinition, VelcronCustomThemeSettings {
+    type: "Icon";
+    icon: string;
+    background?: boolean;
+    size?: number;
+    events?: VelcronOnPressEvent;
+}
+export interface VelcronDimensions {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface VelcronBorder extends VelcronDimensions {
+    color: string;
+}
+export interface VelcronChipDefinition extends VelcronDefinition, VelcronCustomThemeSettings {
+    type: "Chip";
+    text: string;
+    icon?: VelcronIcon;
+    disabled?: boolean;
+    events?: VelcronOnPressEvent;
+}
+export interface VelcronSlotDefinition extends VelcronDefinition, VelcronCustomThemeSettings {
+    type: "Slot";
+    bind: string;
+    value: VelcroncomponentArrayType;
+}
+/*** Custom Components ***********************************************************************/
+export type VelcronCustomComponentDefinition = VelcronComponentDescriptor & VelcronComponentDefinition;
+export type VelcronRenderProps<TDefinition> = {
+    definition: TDefinition;
+    renderContext: VelcronRenderContext;
+};

package/models/VelcronDefinitions.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronImageRatios = void 0;
+var VelcronImageRatios;
+(function (VelcronImageRatios) {
+    VelcronImageRatios[VelcronImageRatios["square"] = 1] = "square";
+    VelcronImageRatios[VelcronImageRatios["landscape"] = 2] = "landscape";
+})(VelcronImageRatios = exports.VelcronImageRatios || (exports.VelcronImageRatios = {}));

package/models/VelcronDescriptors.d.ts

@@ -0,0 +1,35 @@
+import { VelcronComponentPropertyEditors, VelcronDescriptorTypes, VelcronDataTypes } from "./Enums";
+import { VelcroncomponentArrayType, VelcronPrimitiveType } from "./VelcronTypes";
+export interface VelcronDescriptor {
+    descriptorType: VelcronDescriptorTypes;
+    icon: string;
+}
+export interface VelcronComponentDescriptor extends VelcronDescriptor {
+    descriptorType: VelcronDescriptorTypes.component;
+    type: string;
+    icon: string;
+    properties?: Array<VelcronComponentPropertyDescriptor | VelcronComponentArrayPropertyDescriptor>;
+    events?: Array<VelcronComponentEventDescriptor>;
+}
+export interface VelcronSubComponentDescriptor extends VelcronDescriptor {
+    descriptorType: VelcronDescriptorTypes.subComponent;
+    type: string;
+    icon: string;
+    properties?: Array<VelcronComponentPropertyDescriptor | VelcronComponentArrayPropertyDescriptor>;
+    events?: Array<VelcronComponentEventDescriptor>;
+}
+export interface VelcronComponentPropertyDescriptor {
+    name: string;
+    type: VelcronDataTypes;
+    editor?: VelcronComponentPropertyEditors;
+    required?: boolean;
+    defaultValue?: VelcronPrimitiveType | VelcroncomponentArrayType;
+    disableRemovePropertyOnEmptyOrFalse?: boolean;
+}
+export interface VelcronComponentArrayPropertyDescriptor extends VelcronComponentPropertyDescriptor {
+    type: VelcronDataTypes.componentArray;
+    subComponent: VelcronSubComponentDescriptor;
+}
+export interface VelcronComponentEventDescriptor {
+    name: string;
+}

package/models/VelcronDescriptors.js

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

package/models/VelcronEvents.d.ts

@@ -0,0 +1,16 @@
+export type VelcronOnPressEvent = {
+    onPress?: Array<string>;
+};
+export type VelcronOnLoadEvent = {
+    onLoaded?: Array<string>;
+};
+export type VelcronOnChangedEvent = {
+    onChanged?: Array<string>;
+};
+export type VelcronOnCloseRequestedEvent = {
+    onCloseRequested?: Array<string>;
+};
+export type VelcronOnClosedEvent = {
+    onClosed?: Array<string>;
+};
+export type VelcronEvent = {};

package/models/VelcronEvents.js

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

package/models/VelcronTypes.d.ts

@@ -0,0 +1,10 @@
+import { VelcronDefinition } from "./VelcronDefinitions";
+export type VelcronPrimitiveType = string | number | boolean;
+export type VelcronArrayType<T> = Array<T>;
+export type VelcronObjectType<T extends Object> = T;
+export type VelcroncomponentArrayType = Array<VelcronDefinition>;
+export interface DeferredPromise<T> {
+    promise: Promise<T>;
+    resolve: (val: T) => void;
+    reject: () => void;
+}