@singularsystems/neo-core 0.10.74 → 0.10.76

package/dist/Components/ButtonOptions.d.ts

@@ -46,6 +46,10 @@ export interface IButtonOptions {
      * Adds a pulse animation to the button.
      */
     pulse?: boolean;
+    /**
+     * Set a custom variant for when a standard variant is not provided.
+     */
+    customVariant?: string;
 }
 export interface IButtonDropDownItem {
     /** Menu item text or component */

package/dist/Data/Paging/PageManager.d.ts

@@ -82,7 +82,7 @@ export interface IPageManager {
     /**
      * Refresh the data only if the page manager has initialised.
      */
-    resetData(taskRunner?: ITaskRunner): Promise<void>;
+    invalidateData(taskRunner?: ITaskRunner): Promise<void>;
     /**
      * Refresh the data by calling the api endpoint with the current criteria.
      * This will not reset the page index, and will not update the total record count, therefore should only be called if your criteria has not changed since the last full fetch using refreshData().
@@ -135,7 +135,7 @@ export declare class PageManager<TCriteria extends ValueObject, TModel extends I
     /**
      * Refresh the data only if the page manager has initialised.
      */
-    resetData(taskRunner?: ITaskRunner): Promise<void>;
+    invalidateData(taskRunner?: ITaskRunner): Promise<void>;
     /**
      * Refresh the data by calling the api endpoint with the current criteria.
      * This will not reset the page index, and will not update the total record count, therefore should only be called if your criteria has not changed since the last full fetch using refreshData().

package/dist/Data/Paging/PageManager.js

@@ -169,7 +169,7 @@ var PageManager = /** @class */ (function (_super) {
     /**
      * Refresh the data only if the page manager has initialised.
      */
-    PageManager.prototype.resetData = function (taskRunner) {
+    PageManager.prototype.invalidateData = function (taskRunner) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {

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.74",
+  "version": "0.10.76",
   "description": "Core functionality for the Neo client library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",