@gpa-gemstone/common-pages 0.0.151 → 0.0.153

package/lib/BulkUpload.d.ts

@@ -1,41 +1,33 @@
-import * as React from 'react';
 import { Gemstone } from '@gpa-gemstone/application-typings';
 interface IProps<T> {
     /**
     * Attribute used to control what type of files are filtered by default in file explorer
-    * @type {string}
     * */
     FileTypeAttribute: string;
     /**
     * Array of available pipelines to use
-    * @type {IPipeline[]}
     * */
     Pipelines: Gemstone.TSX.Interfaces.IPipeline<T, any>[];
     /**
     * React Component to be used in the Review Step
-    * @type {React.FC<IReviewProps<T>>}
     * */
     ReviewUI: (props: {
         Data: T[];
     }) => JSX.Element;
     /**
     * React Component to be used in the Complete Step
-    * @type {React.FC<IReviewProps<T>>}
     * */
     CompleteUI?: JSX.Element;
     /**
     * Index of the steps array in the current pipline
-    * @type {React.FC<IReviewProps<T>>}
     * */
     CurrentPipelineStep: number;
     /**
     * Setter to pass into the pipeline UI Components
-    * @type {React.FC<IReviewProps<T>>}
     * */
     SetCurrentPipelineStep: (step: number) => void;
     /**
     * Step to represent current stage of component
-    * @type {'Upload' | 'Process' | 'Review' | 'Complete'}
     * */
     Step: Gemstone.TSX.Types.BulkUploadStep;
     /**
@@ -50,14 +42,12 @@ interface IProps<T> {
     SetErrors: (errors: string[]) => void;
     /**
      * Optional Progress Bar component to replace internal Progress Bar.
-     * @type {JSX.Element}
      */
     ProgressBar?: JSX.Element;
     /**
      * Optional flag to call OnComplete handler when the review step is hit.
-     * @type {boolean}
      */
     CompleteOnReview?: boolean;
 }
-export default function BulkUpload<T>(props: IProps<T>): React.JSX.Element;
+export default function BulkUpload<T>(props: IProps<T>): JSX.Element;
 export {};

package/lib/ErrorBoundary.d.ts

@@ -10,9 +10,9 @@ interface IProps {
     ClassName?: string;
     ErrorIconSize?: number;
 }
-export default class ErrorBoundary extends React.Component<IProps, IError> {
+export default class ErrorBoundary extends React.Component<React.PropsWithChildren<IProps>, IError> {
     constructor(props: IProps);
     componentDidCatch(error: IError): void;
-    render(): React.JSX.Element;
+    render(): JSX.Element;
 }
 export {};

package/lib/EventCharacteristicFilter.d.ts

@@ -1,4 +1,3 @@
-import React from 'react';
 import { OpenXDA } from '@gpa-gemstone/application-typings';
 interface IProps {
     setEventFilters: (characteristics?: IEventCharacteristicFilters, types?: number[]) => void;
@@ -36,5 +35,5 @@ interface IEventCharacteristicFilters {
     curveInside: boolean;
     curveOutside: boolean;
 }
-declare const EventCharacteristicFilter: (props: IProps) => React.JSX.Element | null;
+declare const EventCharacteristicFilter: (props: IProps) => JSX.Element | null;
 export default EventCharacteristicFilter;

package/lib/EventTypeFilter.d.ts

@@ -1,4 +1,3 @@
-import React from 'react';
 import 'moment';
 import { OpenXDA } from '@gpa-gemstone/application-typings';
 interface IProps {
@@ -7,5 +6,5 @@ interface IProps {
     EventTypes: OpenXDA.Types.EventType[];
     SelectedTypeID: number[];
 }
-declare const EventTypeFilter: React.FC<IProps>;
+declare const EventTypeFilter: (props: IProps) => JSX.Element;
 export default EventTypeFilter;

package/lib/Gemstone/ControllerFunctions.d.ts

@@ -0,0 +1,22 @@
+import { Gemstone } from "./Gemstone";
+export declare class ReadOnlyControllerFunctions<T> {
+    protected APIPath: string;
+    constructor(APIPath: string);
+    GetPageInfo: (filter?: Gemstone.Types.ISearchFilter<T>[], parentID?: string | number) => JQuery.jqXHR<Gemstone.Types.IPageInfo>;
+    GetOne: (id: string | number) => JQuery.jqXHR<T>;
+    GetPage: (page: number, sortField?: keyof T, asc?: boolean, parentID?: string | number) => JQuery.jqXHR<T[]>;
+    /**
+     * Use with caution as this could be VERY network resource intensive.
+     */
+    GetAll: (sortField: keyof T, asc: boolean, filter?: Gemstone.Types.ISearchFilter<T>[], parentID?: string | number) => JQuery.jqXHR<T[]>;
+    SearchPage: (page: number, sortField: keyof T, asc: boolean, filter: Gemstone.Types.ISearchFilter<T>[], parentID?: number | string) => JQuery.jqXHR<T[]>;
+    New: () => JQuery.jqXHR<T>;
+    GetMaxValue: (fieldName: keyof T) => JQuery.jqXHR<number>;
+}
+export declare class ReadWriteControllerFunctions<T> extends ReadOnlyControllerFunctions<T> {
+    constructor(APIPath: string);
+    Add: (record: T) => JQuery.jqXHR<T>;
+    Update: (record: T) => JQuery.jqXHR<T>;
+    Delete: (record: T) => JQuery.jqXHR<T>;
+    DeleteByID: (id: string | number) => JQuery.jqXHR<T>;
+}

package/lib/Gemstone/ControllerFunctions.js

@@ -0,0 +1,266 @@
+"use strict";
+//******************************************************************************************************
+//  ControllerFunctions.tsx - Gbtc
+//
+//  Copyright (c) 2024, Grid Protection Alliance.  All Rights Reserved.
+//
+//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
+//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
+//  The GPA may license this file to you under the MIT License (MIT), the "License"; you may not use this
+//  file except in compliance with the License. You may obtain a copy of the License at:
+//
+//      http://opensource.org/licenses/MIT
+//
+//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
+//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
+//  License for the specific language governing permissions and limitations.
+//
+//  Code Modification History:
+//  ----------------------------------------------------------------------------------------------------
+//  04/02/2024 - C. Lackner
+//       Generated original version of source code.
+//
+//******************************************************************************************************
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadWriteControllerFunctions = exports.ReadOnlyControllerFunctions = void 0;
+var jquery_1 = __importDefault(require("jquery"));
+var ReadOnlyControllerFunctions = /** @class */ (function () {
+    function ReadOnlyControllerFunctions(APIPath) {
+        var _this = this;
+        this.GetPageInfo = function (filter, parentID) {
+            var route = parentID == null ? "".concat(_this.APIPath, "/PageInfo") : "".concat(_this.APIPath, "/PageInfo/").concat(parentID);
+            if (filter === undefined || filter.length === 0)
+                return jquery_1.default.ajax({
+                    type: 'GET',
+                    url: "".concat(route),
+                    contentType: "application/json; charset=utf-8",
+                    dataType: 'json',
+                    cache: false,
+                    async: true
+                });
+            return jquery_1.default.ajax({
+                type: 'POST',
+                url: "".concat(route),
+                contentType: "application/json; charset=utf-8",
+                dataType: 'json',
+                data: JSON.stringify({ Searches: filter, OrderBy: '', Ascending: false }),
+                cache: false,
+                async: true
+            });
+        };
+        this.GetOne = function (id) {
+            return jquery_1.default.ajax({
+                type: 'GET',
+                url: "".concat(_this.APIPath, "/One/").concat(id),
+                contentType: "application/json; charset=utf-8",
+                dataType: 'json',
+                cache: false,
+                async: true
+            });
+        };
+        this.GetPage = function (page, sortField, asc, parentID) {
+            if (sortField == null || asc == null) {
+                if (parentID != null) {
+                    return jquery_1.default.ajax({
+                        type: 'GET',
+                        url: "".concat(_this.APIPath, "/").concat(page, "/").concat(parentID),
+                        contentType: "application/json; charset=utf-8",
+                        dataType: 'json',
+                        cache: false,
+                        async: true
+                    });
+                }
+                return jquery_1.default.ajax({
+                    type: 'GET',
+                    url: "".concat(_this.APIPath, "/").concat(page),
+                    contentType: "application/json; charset=utf-8",
+                    dataType: 'json',
+                    cache: false,
+                    async: true
+                });
+            }
+            if (parentID != null)
+                return jquery_1.default.ajax({
+                    type: 'GET',
+                    url: "".concat(_this.APIPath, "/").concat(page, "/").concat(parentID, "/").concat(sortField.toString(), "/").concat(asc),
+                    contentType: "application/json; charset=utf-8",
+                    dataType: 'json',
+                    cache: false,
+                    async: true
+                });
+            return jquery_1.default.ajax({
+                type: 'GET',
+                url: "".concat(_this.APIPath, "/").concat(page, "/").concat(sortField.toString(), "/").concat(asc),
+                contentType: "application/json; charset=utf-8",
+                dataType: 'json',
+                cache: false,
+                async: true
+            });
+        };
+        /**
+         * Use with caution as this could be VERY network resource intensive.
+         */
+        this.GetAll = function (sortField, asc, filter, parentID) {
+            var deferred = jquery_1.default.Deferred();
+            var pending = [];
+            // First, determine the number of pages.
+            var pagReq = _this.GetPageInfo(filter !== null && filter !== void 0 ? filter : [], parentID).done(function (pageInfo) {
+                var pageCount = pageInfo.PageCount;
+                if (pageCount <= 0) {
+                    deferred.resolve([]);
+                    return;
+                }
+                // Build an array of page requests.
+                var pageRequests = [];
+                for (var i = 0; i < pageCount; i++) {
+                    var req = _this.SearchPage(i, sortField, asc, filter !== null && filter !== void 0 ? filter : [], parentID);
+                    pageRequests.push(req);
+                    pending.push(req);
+                }
+                // Combine all page requests.
+                jquery_1.default.when.apply(jquery_1.default, pageRequests).done(function () {
+                    var _a;
+                    var results = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        results[_i] = arguments[_i];
+                    }
+                    // If there's only one page, 'arguments' is not an array of arrays.
+                    var responses = pageRequests.length === 1 ? [results] : jquery_1.default.makeArray(results);
+                    var pages = responses.map(function (result) { return result[0]; });
+                    var allData = (_a = []).concat.apply(_a, pages);
+                    deferred.resolve(allData);
+                }).fail(function (err) { return deferred.reject(err); });
+            }).fail(function (err) { return deferred.reject(err); });
+            pending.push(pagReq);
+            // Attach an abort handler to cancel all pending requests.
+            var promise = deferred.promise();
+            promise.abort = function () {
+                pending.forEach(function (req) { return req.abort(); });
+                deferred.reject('Aborted');
+            };
+            return promise;
+        };
+        this.SearchPage = function (page, sortField, asc, filter, parentID) {
+            if (parentID != null)
+                return jquery_1.default.ajax({
+                    type: 'POST',
+                    url: "".concat(_this.APIPath, "/Search/").concat(page, "/").concat(parentID),
+                    contentType: "application/json; charset=utf-8",
+                    dataType: 'json',
+                    data: JSON.stringify({
+                        Searches: filter,
+                        OrderBy: sortField,
+                        Ascending: asc
+                    }),
+                    cache: false,
+                    async: true
+                });
+            return jquery_1.default.ajax({
+                type: 'POST',
+                url: "".concat(_this.APIPath, "/Search/").concat(page),
+                contentType: "application/json; charset=utf-8",
+                dataType: 'json',
+                data: JSON.stringify({
+                    Searches: filter,
+                    OrderBy: sortField,
+                    Ascending: asc
+                }),
+                cache: false,
+                async: true
+            });
+        };
+        this.New = function () {
+            return jquery_1.default.ajax({
+                type: 'GET',
+                url: "".concat(_this.APIPath, "/New"),
+                contentType: "application/json; charset=utf-8",
+                dataType: 'json',
+                cache: false,
+                async: true
+            });
+        };
+        this.GetMaxValue = function (fieldName) {
+            return jquery_1.default.ajax({
+                type: 'GET',
+                url: "".concat(_this.APIPath, "/Max/").concat(fieldName),
+                contentType: "application/json; charset=utf-8",
+                dataType: 'json',
+                cache: false,
+                async: true
+            });
+        };
+        this.APIPath = APIPath;
+    }
+    return ReadOnlyControllerFunctions;
+}());
+exports.ReadOnlyControllerFunctions = ReadOnlyControllerFunctions;
+var ReadWriteControllerFunctions = /** @class */ (function (_super) {
+    __extends(ReadWriteControllerFunctions, _super);
+    function ReadWriteControllerFunctions(APIPath) {
+        var _this = _super.call(this, APIPath) || this;
+        _this.Add = function (record) {
+            return jquery_1.default.ajax({
+                type: 'POST',
+                url: "".concat(_this.APIPath),
+                contentType: "application/json; charset=utf-8",
+                dataType: 'json',
+                data: JSON.stringify(record),
+                cache: false,
+                async: true
+            });
+        };
+        _this.Update = function (record) {
+            return jquery_1.default.ajax({
+                type: 'PATCH',
+                url: "".concat(_this.APIPath),
+                contentType: "application/json; charset=utf-8",
+                dataType: 'json',
+                data: JSON.stringify(record),
+                cache: false,
+                async: true
+            });
+        };
+        _this.Delete = function (record) {
+            return jquery_1.default.ajax({
+                type: 'DELETE',
+                url: "".concat(_this.APIPath),
+                contentType: "application/json; charset=utf-8",
+                dataType: 'json',
+                data: JSON.stringify(record),
+                cache: false,
+                async: true
+            });
+        };
+        _this.DeleteByID = function (id) {
+            return jquery_1.default.ajax({
+                type: 'DELETE',
+                url: "".concat(_this.APIPath, "/").concat(id),
+                contentType: "application/json; charset=utf-8",
+                dataType: 'json',
+                cache: false,
+                async: true
+            });
+        };
+        return _this;
+    }
+    return ReadWriteControllerFunctions;
+}(ReadOnlyControllerFunctions));
+exports.ReadWriteControllerFunctions = ReadWriteControllerFunctions;

package/lib/Gemstone/Gemstone.d.ts

@@ -0,0 +1,18 @@
+import { Search } from "@gpa-gemstone/react-interactive";
+export declare namespace Gemstone {
+    namespace Types {
+        interface ISearchFilter<T> {
+            FieldName: keyof T;
+            SearchParameter: string | boolean | number | string[] | number[] | boolean[];
+            Operator: Search.OperatorType;
+        }
+        interface IPageInfo {
+            PageSize: number;
+            PageCount: number;
+            TotalCount: number;
+        }
+    }
+    namespace HelperFunctions {
+        const getSearchFilter: <T>(searchFilter: Search.IFilter<T>[]) => Types.ISearchFilter<T>[];
+    }
+}

package/lib/Gemstone/Gemstone.js

@@ -0,0 +1,41 @@
+"use strict";
+//******************************************************************************************************
+//  Gemstone.tsx - Gbtc
+//
+//  Copyright (c) 2025, Grid Protection Alliance.  All Rights Reserved.
+//
+//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
+//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
+//  The GPA may license this file to you under the MIT License (MIT), the "License"; you may not use this
+//  file except in compliance with the License. You may obtain a copy of the License at:
+//
+//      http://opensource.org/licenses/MIT
+//
+//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
+//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
+//  License for the specific language governing permissions and limitations.
+//
+//  Code Modification History:
+//  ----------------------------------------------------------------------------------------------------
+//  09/12/2025 - Preston Crawford
+//       Generated original version of source code.
+//
+//******************************************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gemstone = void 0;
+var Gemstone;
+(function (Gemstone) {
+    var HelperFunctions;
+    (function (HelperFunctions) {
+        HelperFunctions.getSearchFilter = function (searchFilter) {
+            return searchFilter.map(function (s) {
+                var searchText = s.SearchText;
+                if (s.Operator === 'IN' || s.Operator === 'NOT IN') {
+                    if (searchText.startsWith('(') && searchText.endsWith(')'))
+                        searchText = searchText.slice(1, -1).split(',').map(function (v) { return v.trim(); });
+                }
+                return { FieldName: s.FieldName, SearchParameter: searchText, Operator: s.Operator };
+            });
+        };
+    })(HelperFunctions = Gemstone.HelperFunctions || (Gemstone.HelperFunctions = {}));
+})(Gemstone || (exports.Gemstone = Gemstone = {}));

package/lib/Gemstone/GenericSlices/ReadOnlyGenericSlice.d.ts

@@ -0,0 +1,51 @@
+import { AsyncThunk, Slice, ActionReducerMapBuilder, Reducer } from '@reduxjs/toolkit';
+import { ReadOnlyControllerFunctions } from '../ControllerFunctions';
+import { Application } from '@gpa-gemstone/application-typings';
+import { Gemstone } from '../Gemstone';
+export interface IError {
+    Message: string;
+    Action: 'FETCH' | 'UPDATE' | 'ADD' | 'DELETE';
+    Time: string;
+}
+export interface IState<T> {
+    FetchStatus: Application.Types.Status;
+    Data: T[];
+    SortField: keyof T;
+    Ascending: boolean;
+    Filter: Gemstone.Types.ISearchFilter<T>[];
+    PageInfo: Gemstone.Types.IPageInfo;
+    ParentID: string | number | null;
+    ActiveID: string[];
+    Error: (IError | null);
+}
+export interface IFetchThunkArg<T> {
+    sortField?: keyof T;
+    ascending?: boolean;
+    parentID?: string | number;
+    filter?: Gemstone.Types.ISearchFilter<T>[];
+}
+export interface IReadOnlyThunkReturn<T> {
+    Data: T[];
+}
+/**
+ * A generic class providing functionalities related to a slice of data.
+ */
+export default class ReadOnlyGenericSlice<T> {
+    protected Name: string;
+    protected Slice: Slice<any>;
+    Fetch: AsyncThunk<IReadOnlyThunkReturn<T>, IFetchThunkArg<T>, {}>;
+    SetStatusToChanged: AsyncThunk<void, void, {}>;
+    Reducer: Reducer<IState<T>>;
+    private fetchHandle;
+    protected controller: ReadOnlyControllerFunctions<T>;
+    constructor(name: string, defaultSortField: keyof T, ascending: boolean, apiPath: string);
+    constructor(name: string, defaultSortField: keyof T, ascending: boolean, readonlyController: ReadOnlyControllerFunctions<T>);
+    protected initializeSlice(defaultSortField: keyof T, ascending?: boolean): void;
+    protected addExtraReducers(builder: ActionReducerMapBuilder<IState<T>>): void;
+    Data: (state: any) => T[];
+    Error: (state: any) => IError | null;
+    FetchStatus: (state: any) => Application.Types.Status;
+    SortField: (state: any) => keyof T;
+    Ascending: (state: any) => boolean;
+    ParentID: (state: any) => string | number | null;
+}