@singularsystems/neo-core 0.10.75 → 0.10.76

package/dist/JsonSchema/ClassMetadata.d.ts

@@ -1,7 +1,8 @@
 import { PropertyMetadata } from './PropertyMetadata';
 import { IJsonObjectType } from './JsonSchemaTypes';
 import { ITypeCacheInternal } from './TypeCache';
-export declare class ClassMetadata {
+import { MetadataBase } from './MetadataBase';
+export declare class ClassMetadata extends MetadataBase {
     name: string;
     constructor(name: string);
     /**

package/dist/JsonSchema/ClassMetadata.js

@@ -1,31 +1,36 @@
+import { __extends } from "tslib";
 import { TypeMetadata } from './TypeMetadata';
 import { PropertyMetadata } from './PropertyMetadata';
-var ClassMetadata = /** @class */ (function () {
+import { MetadataBase } from './MetadataBase';
+var ClassMetadata = /** @class */ (function (_super) {
+    __extends(ClassMetadata, _super);
     function ClassMetadata(name) {
-        this.name = name;
+        var _this = _super.call(this) || this;
+        _this.name = name;
         /**
          * All properties.
          */
-        this.properties = [];
+        _this.properties = [];
         /**
          * Properties excluding child objects and lists.
          */
-        this.simpleProperties = [];
+        _this.simpleProperties = [];
         /**
          * Properties containing child object types.
          */
-        this.childObjectProperties = [];
+        _this.childObjectProperties = [];
         /**
          * Properties containing child list types.
          */
-        this.childListProperties = [];
+        _this.childListProperties = [];
+        return _this;
     }
     ClassMetadata.prototype.loadMetaData = function (schema, cache) {
+        _super.prototype.loadFromSchema.call(this, schema);
         for (var propertyKey in schema.properties) {
             var propertySchema = schema.properties[propertyKey];
             var propertyMetaData = new PropertyMetadata(propertyKey, TypeMetadata.create(propertySchema, cache));
-            propertyMetaData.title = propertySchema.title;
-            propertyMetaData.description = propertySchema.description;
+            propertyMetaData.loadFromSchema(propertySchema);
             if (propertyMetaData.type.basicType !== "unknown") {
                 this.properties.push(propertyMetaData);
                 if (propertyMetaData.type.basicType === "array") {
@@ -49,5 +54,5 @@ var ClassMetadata = /** @class */ (function () {
         return clone;
     };
     return ClassMetadata;
-}());
+}(MetadataBase));
 export { ClassMetadata };

package/dist/JsonSchema/MetadataBase.d.ts

@@ -0,0 +1,8 @@
+import { IJsonSchemaDescriptorType } from "./JsonSchemaTypes";
+export declare class MetadataBase {
+    title?: string;
+    description?: string;
+    ordinal?: number;
+    hidden?: boolean;
+    loadFromSchema(schema: IJsonSchemaDescriptorType): void;
+}

package/dist/JsonSchema/MetadataBase.js

@@ -0,0 +1,12 @@
+var MetadataBase = /** @class */ (function () {
+    function MetadataBase() {
+    }
+    MetadataBase.prototype.loadFromSchema = function (schema) {
+        this.title = schema.title;
+        this.description = schema.description;
+        this.ordinal = schema["x-ordinal"];
+        this.hidden = schema["x-hidden"];
+    };
+    return MetadataBase;
+}());
+export { MetadataBase };

package/dist/JsonSchema/PropertyMetadata.d.ts

@@ -1,8 +1,12 @@
+import { IJsonSchemaDescriptorType } from './JsonSchemaTypes';
+import { MetadataBase } from './MetadataBase';
 import { TypeMetadata } from './TypeMetadata';
-export declare class PropertyMetadata {
+export declare class PropertyMetadata extends MetadataBase {
     propertyName: string;
     type: TypeMetadata;
     constructor(propertyName: string, type: TypeMetadata);
-    title?: string;
-    description?: string;
+    formatString?: string;
+    width?: number;
+    hAlign?: "left" | "center" | "right";
+    loadFromSchema(schema: IJsonSchemaDescriptorType): void;
 }

package/dist/JsonSchema/PropertyMetadata.js

@@ -1,8 +1,19 @@
-var PropertyMetadata = /** @class */ (function () {
+import { __extends } from "tslib";
+import { MetadataBase } from './MetadataBase';
+var PropertyMetadata = /** @class */ (function (_super) {
+    __extends(PropertyMetadata, _super);
     function PropertyMetadata(propertyName, type) {
-        this.propertyName = propertyName;
-        this.type = type;
+        var _this = _super.call(this) || this;
+        _this.propertyName = propertyName;
+        _this.type = type;
+        return _this;
     }
+    PropertyMetadata.prototype.loadFromSchema = function (schema) {
+        _super.prototype.loadFromSchema.call(this, schema);
+        this.formatString = schema["x-formatString"];
+        this.width = schema["x-width"];
+        this.hAlign = schema["x-hAlign"];
+    };
     return PropertyMetadata;
-}());
+}(MetadataBase));
 export { PropertyMetadata };

package/dist/JsonSchema/TypeCache.js

@@ -20,6 +20,7 @@ var TypeCache = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    // This is an internal method used by TypeMetadata
     TypeCache.prototype.getOrAddType = function (name) {
         if (name.startsWith("#/definitions/")) {
             name = name.replace("#/definitions/", "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@singularsystems/neo-core",
-  "version": "0.10.75",
+  "version": "0.10.76",
   "description": "Core functionality for the Neo client library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",