@react-typed-forms/schemas 3.0.0-dev.100

package/lib/schemaBuilder.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultCompoundField = exports.defaultScalarField = exports.compoundField = exports.boolField = exports.intField = exports.makeCompoundField = exports.makeScalarField = exports.withScalarOptions = exports.stringOptionsField = exports.stringField = exports.buildSchema = void 0;
+const types_1 = require("./types");
+function buildSchema(def) {
+    return Object.entries(def).map((x) => x[1](x[0]));
+}
+exports.buildSchema = buildSchema;
+function stringField(displayName, options) {
+    return makeScalarField(Object.assign({ type: types_1.FieldType.String, displayName }, options));
+}
+exports.stringField = stringField;
+function stringOptionsField(displayName, ...options) {
+    return makeScalarField({
+        type: types_1.FieldType.String,
+        displayName,
+        restrictions: { options },
+    });
+}
+exports.stringOptionsField = stringOptionsField;
+function withScalarOptions(options, v) {
+    return (n) => (Object.assign(Object.assign({}, v(n)), options));
+}
+exports.withScalarOptions = withScalarOptions;
+function makeScalarField(options) {
+    return (n) => (Object.assign(Object.assign({}, defaultScalarField(n, n)), options));
+}
+exports.makeScalarField = makeScalarField;
+function makeCompoundField(options) {
+    return (n) => (Object.assign(Object.assign({}, defaultCompoundField(n, n, false)), options));
+}
+exports.makeCompoundField = makeCompoundField;
+function intField(displayName, options) {
+    return makeScalarField(Object.assign({ type: types_1.FieldType.Int, displayName }, options));
+}
+exports.intField = intField;
+function boolField(displayName, options) {
+    return makeScalarField(Object.assign({ type: types_1.FieldType.Bool, displayName }, options));
+}
+exports.boolField = boolField;
+function compoundField(displayName, fields, other) {
+    return (field) => (Object.assign(Object.assign(Object.assign({}, defaultCompoundField(field, displayName, false)), other), { children: fields }));
+}
+exports.compoundField = compoundField;
+function defaultScalarField(field, displayName) {
+    return {
+        restrictions: {
+            options: [],
+        },
+        tags: [],
+        field,
+        displayName,
+        type: types_1.FieldType.String,
+        collection: false,
+        searchable: false,
+        schemaType: types_1.SchemaFieldType.Scalar,
+        system: false,
+        entityRefType: "",
+        parentField: "",
+        required: false,
+        defaultValue: undefined,
+        onlyForTypes: [],
+        isTypeField: false,
+    };
+}
+exports.defaultScalarField = defaultScalarField;
+function defaultCompoundField(field, displayName, collection) {
+    return {
+        tags: [],
+        field,
+        displayName,
+        type: types_1.FieldType.Compound,
+        collection,
+        schemaType: types_1.SchemaFieldType.Compound,
+        system: false,
+        treeChildren: false,
+        children: [],
+        onlyForTypes: [],
+        required: true,
+    };
+}
+exports.defaultCompoundField = defaultCompoundField;

package/lib/types.d.ts

@@ -0,0 +1,199 @@
+export interface SchemaField {
+    schemaType: SchemaFieldType;
+    field: string;
+    displayName: string;
+    type: FieldType;
+    tags: string[];
+    system: boolean;
+    collection: boolean;
+    onlyForTypes: string[];
+    required: boolean;
+}
+export declare enum SchemaFieldType {
+    Scalar = "Scalar",
+    Compound = "Compound"
+}
+export declare enum FieldType {
+    String = "String",
+    Bool = "Bool",
+    Int = "Int",
+    Date = "Date",
+    DateTime = "DateTime",
+    Double = "Double",
+    EntityRef = "EntityRef",
+    Compound = "Compound",
+    AutoId = "AutoId",
+    Image = "Image"
+}
+export interface ScalarField extends SchemaField {
+    entityRefType: string;
+    parentField: string;
+    searchable: boolean;
+    defaultValue: any;
+    isTypeField: boolean;
+    restrictions: SchemaRestrictions | undefined;
+}
+export interface SchemaRestrictions {
+    options: FieldOption[] | undefined;
+}
+export interface FieldOption {
+    name: string;
+    value: any;
+}
+export interface CompoundField extends SchemaField {
+    children: SchemaField[];
+    treeChildren: boolean;
+}
+export type AnyControlDefinition = DataControlDefinition | GroupedControlsDefinition | ActionControlDefinition | DisplayControlDefinition;
+export interface ControlDefinition {
+    type: string;
+    title?: string;
+    dynamic?: DynamicProperty[];
+    adornments?: ControlAdornment[];
+}
+export declare enum ControlDefinitionType {
+    Data = "Data",
+    Group = "Group",
+    Display = "Display",
+    Action = "Action"
+}
+export interface DynamicProperty {
+    type: DynamicPropertyType;
+    expr: EntityExpression;
+}
+export declare enum DynamicPropertyType {
+    Visible = "Visible",
+    DefaultValue = "DefaultValue"
+}
+export interface EntityExpression {
+    type: ExpressionType;
+}
+export declare enum ExpressionType {
+    Jsonata = "Jsonata",
+    FieldValue = "FieldValue",
+    UserMatch = "UserMatch"
+}
+export interface JsonataExpression extends EntityExpression {
+    expression: string;
+}
+export interface FieldValueExpression extends EntityExpression {
+    field: string;
+    value: any;
+}
+export interface UserMatchExpression extends EntityExpression {
+    userMatch: string;
+}
+export interface ControlAdornment {
+    type: ControlAdornmentType;
+}
+export declare enum ControlAdornmentType {
+    Tooltip = "Tooltip",
+    Accordion = "Accordion"
+}
+export interface TooltipAdornment extends ControlAdornment {
+    tooltip: string;
+}
+export interface AccordionAdornment extends ControlAdornment {
+    title: string;
+    defaultExpanded: boolean;
+}
+export interface DataControlDefinition extends ControlDefinition {
+    type: ControlDefinitionType.Data;
+    field: string;
+    required?: boolean;
+    renderOptions: RenderOptions;
+    defaultValue?: any;
+    readonly?: boolean;
+}
+export interface RenderOptions {
+    type: DataRenderType;
+}
+export declare enum DataRenderType {
+    Standard = "Standard",
+    Radio = "Radio",
+    HtmlEditor = "HtmlEditor",
+    IconList = "IconList",
+    CheckList = "CheckList",
+    UserSelection = "UserSelection",
+    Synchronised = "Synchronised",
+    IconSelector = "IconSelector",
+    DateTime = "DateTime"
+}
+export interface RadioButtonRenderOptions extends RenderOptions {
+}
+export interface StandardRenderer extends RenderOptions {
+}
+export interface HtmlEditorRenderOptions extends RenderOptions {
+    allowImages: boolean;
+}
+export interface DateTimeRenderOptions extends RenderOptions {
+    format?: string;
+}
+export interface IconListRenderOptions extends RenderOptions {
+    iconMappings: IconMapping[];
+}
+export interface IconMapping {
+    value: string;
+    materialIcon: string | undefined;
+}
+export interface CheckListRenderOptions extends RenderOptions {
+}
+export interface SynchronisedRenderOptions extends RenderOptions {
+    fieldToSync: string;
+    syncType: SyncTextType;
+}
+export declare enum SyncTextType {
+    Camel = "Camel",
+    Snake = "Snake",
+    Pascal = "Pascal"
+}
+export interface UserSelectionRenderOptions extends RenderOptions {
+    noGroups: boolean;
+    noUsers: boolean;
+}
+export interface IconSelectionRenderOptions extends RenderOptions {
+}
+export interface GroupedControlsDefinition extends ControlDefinition {
+    type: ControlDefinitionType.Group;
+    children: AnyControlDefinition[];
+    compoundField?: string;
+    groupOptions: GroupRenderOptions;
+}
+export interface GroupRenderOptions {
+    type: GroupRenderType;
+    hideTitle?: boolean;
+}
+export declare enum GroupRenderType {
+    Standard = "Standard",
+    Grid = "Grid",
+    GroupElement = "GroupElement"
+}
+export interface StandardGroupRenderer extends GroupRenderOptions {
+}
+export interface GroupElementRenderer extends GroupRenderOptions {
+    value: any;
+}
+export interface GridRenderer extends GroupRenderOptions {
+    columns: number | undefined;
+}
+export interface DisplayControlDefinition extends ControlDefinition {
+    type: ControlDefinitionType.Display;
+    displayData: DisplayData;
+}
+export interface DisplayData {
+    type: DisplayDataType;
+}
+export declare enum DisplayDataType {
+    Text = "Text",
+    Html = "Html"
+}
+export interface TextDisplay extends DisplayData {
+    text: string;
+}
+export interface HtmlDisplay extends DisplayData {
+    html: string;
+}
+export interface ActionControlDefinition extends ControlDefinition {
+    type: ControlDefinitionType.Action;
+    actionId: string;
+}

package/lib/types.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisplayDataType = exports.GroupRenderType = exports.SyncTextType = exports.DataRenderType = exports.ControlAdornmentType = exports.ExpressionType = exports.DynamicPropertyType = exports.ControlDefinitionType = exports.FieldType = exports.SchemaFieldType = void 0;
+var SchemaFieldType;
+(function (SchemaFieldType) {
+    SchemaFieldType["Scalar"] = "Scalar";
+    SchemaFieldType["Compound"] = "Compound";
+})(SchemaFieldType = exports.SchemaFieldType || (exports.SchemaFieldType = {}));
+var FieldType;
+(function (FieldType) {
+    FieldType["String"] = "String";
+    FieldType["Bool"] = "Bool";
+    FieldType["Int"] = "Int";
+    FieldType["Date"] = "Date";
+    FieldType["DateTime"] = "DateTime";
+    FieldType["Double"] = "Double";
+    FieldType["EntityRef"] = "EntityRef";
+    FieldType["Compound"] = "Compound";
+    FieldType["AutoId"] = "AutoId";
+    FieldType["Image"] = "Image";
+})(FieldType = exports.FieldType || (exports.FieldType = {}));
+var ControlDefinitionType;
+(function (ControlDefinitionType) {
+    ControlDefinitionType["Data"] = "Data";
+    ControlDefinitionType["Group"] = "Group";
+    ControlDefinitionType["Display"] = "Display";
+    ControlDefinitionType["Action"] = "Action";
+})(ControlDefinitionType = exports.ControlDefinitionType || (exports.ControlDefinitionType = {}));
+var DynamicPropertyType;
+(function (DynamicPropertyType) {
+    DynamicPropertyType["Visible"] = "Visible";
+    DynamicPropertyType["DefaultValue"] = "DefaultValue";
+})(DynamicPropertyType = exports.DynamicPropertyType || (exports.DynamicPropertyType = {}));
+var ExpressionType;
+(function (ExpressionType) {
+    ExpressionType["Jsonata"] = "Jsonata";
+    ExpressionType["FieldValue"] = "FieldValue";
+    ExpressionType["UserMatch"] = "UserMatch";
+})(ExpressionType = exports.ExpressionType || (exports.ExpressionType = {}));
+var ControlAdornmentType;
+(function (ControlAdornmentType) {
+    ControlAdornmentType["Tooltip"] = "Tooltip";
+    ControlAdornmentType["Accordion"] = "Accordion";
+})(ControlAdornmentType = exports.ControlAdornmentType || (exports.ControlAdornmentType = {}));
+var DataRenderType;
+(function (DataRenderType) {
+    DataRenderType["Standard"] = "Standard";
+    DataRenderType["Radio"] = "Radio";
+    DataRenderType["HtmlEditor"] = "HtmlEditor";
+    DataRenderType["IconList"] = "IconList";
+    DataRenderType["CheckList"] = "CheckList";
+    DataRenderType["UserSelection"] = "UserSelection";
+    DataRenderType["Synchronised"] = "Synchronised";
+    DataRenderType["IconSelector"] = "IconSelector";
+    DataRenderType["DateTime"] = "DateTime";
+})(DataRenderType = exports.DataRenderType || (exports.DataRenderType = {}));
+var SyncTextType;
+(function (SyncTextType) {
+    SyncTextType["Camel"] = "Camel";
+    SyncTextType["Snake"] = "Snake";
+    SyncTextType["Pascal"] = "Pascal";
+})(SyncTextType = exports.SyncTextType || (exports.SyncTextType = {}));
+var GroupRenderType;
+(function (GroupRenderType) {
+    GroupRenderType["Standard"] = "Standard";
+    GroupRenderType["Grid"] = "Grid";
+    GroupRenderType["GroupElement"] = "GroupElement";
+})(GroupRenderType = exports.GroupRenderType || (exports.GroupRenderType = {}));
+var DisplayDataType;
+(function (DisplayDataType) {
+    DisplayDataType["Text"] = "Text";
+    DisplayDataType["Html"] = "Html";
+})(DisplayDataType = exports.DisplayDataType || (exports.DisplayDataType = {}));

package/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "@react-typed-forms/schemas",
+	"version": "3.0.0-dev.100",
+	"description": "",
+	"main": "lib/index.js",
+	"types": "lib/index.d.ts",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/doolse/react-typed-forms.git"
+	},
+	"author": "Jolse Maginnis",
+	"license": "ISC",
+	"bugs": {
+		"url": "https://github.com/doolse/react-typed-forms/issues"
+	},
+	"homepage": "https://github.com/doolse/react-typed-forms#readme",
+	"publishConfig": {
+		"access": "public"
+	},
+	"keywords": [
+		"react",
+		"typescript",
+		"forms",
+		"material-ui"
+	],
+	"dependencies": {
+		"@react-typed-forms/core": "3.0.0-dev.100"
+	},
+	"devDependencies": {
+		"@types/react": "^18.0.22",
+		"nswag": "^13.18.2",
+		"react": "^18.2.0",
+		"react-dom": "^18.2.0",
+		"rimraf": "^3.0.2"
+	},
+	"gitHead": "698e16cd3ab31b7dd0528fc76536f4d3205ce8c6",
+	"scripts": {
+		"build": "rimraf ./lib/ && tsc",
+		"watch": "tsc -w",
+		"gencode": "nswag swagger2tsclient /input:http://localhost:5216/swagger/v1/swagger.json /runtime:Net60 /output:src/types.ts /GenerateClientClasses:false /MarkOptionalProperties:false /Template:Fetch /TypeStyle:Interface /DateTimeType:string"
+	}
+}

package/schemas.build.log

@@ -0,0 +1,2 @@
+Invoking: rimraf ./lib/ && tsc 
+