@sankhyalabs/sankhyablocks 1.0.12 → 1.1.12

package/dist/collection/lib/http/data-fetcher/fetchers/dataunit-fetcher.js

@@ -0,0 +1,157 @@
+import { DataUnit, } from "@sankhyalabs/core";
+import { HttpFetcher } from "../DataFetcher";
+import { gql } from "graphql-request";
+export default class DataUnitFetcher {
+  constructor() {
+    this.templateByQuery = new Map();
+    this.buldTemplates();
+  }
+  buldTemplates() {
+    this.templateByQuery.set("fetchDataUnit", gql `query($name: String!) {
+              $queryAlias$: fetchDataUnit(name: $name){
+                name
+                fields{
+                  name
+                  defaultValue
+                  label
+                  readOnly
+                  required
+                  dataType
+                  userInterface
+                  properties{
+                    name
+                    value
+                  }
+                  dependencies{
+                    masterFields
+                    type
+                    expression
+                  }
+                }
+              }
+            }`);
+    this.templateByQuery.set("fetchData", gql `query($dataunit: String! $first: Int $offset:Int $filter: [Filter!] $sort: [Sort!]) {
+            $queryAlias$: fetchDataUnit(name: $dataunit){
+              data(first: $first offset: $offset filters: $filter sort: $sort){
+                first
+                offset
+                total
+                hasMore
+                records{
+                  id
+                  fields {
+                    name
+                    value
+                  }
+                }
+              }
+            }
+          }`);
+    this.templateByQuery.set("saveData", gql `mutation($changes: [Change!]!) {
+            $queryAlias$: saveDataUnitChanges(changes: $changes){
+              oldId
+              id
+              fields {
+                name
+                value
+              }
+            }
+          }`);
+  }
+  getDataUnit(entityName, resourceID) {
+    const dataUnit = new DataUnit(`dd://${entityName}/${resourceID}`);
+    dataUnit.metadataLoader = (dataUnit) => this.loadMetadata(dataUnit);
+    dataUnit.dataLoader = (dataUnit, sort, filters) => this.loadData(dataUnit, sort, filters);
+    dataUnit.saveLoader = (dataUnit, changes) => this.saveData(dataUnit, changes);
+    return dataUnit;
+  }
+  loadMetadata(dataUnit) {
+    return new Promise((resolve, reject) => {
+      HttpFetcher.get()
+        .callGraphQL({
+        values: { name: dataUnit.name },
+        query: this.templateByQuery.get("fetchDataUnit"),
+      })
+        .then((resp) => {
+        var _a;
+        const metadata = {
+          name: resp.name,
+          label: resp.name,
+          fields: [],
+        };
+        (_a = resp.fields) === null || _a === void 0 ? void 0 : _a.forEach((source) => {
+          let properties = undefined;
+          if (Array.isArray(source.properties)) {
+            properties = {};
+            source.properties.forEach((prop) => (properties[prop.name] = prop.value));
+          }
+          metadata.fields.push(Object.assign(Object.assign({}, source), { properties }));
+        });
+        resolve(metadata);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  loadData(dataUnit, sort, filters) {
+    return new Promise((resolve, reject) => {
+      HttpFetcher.get()
+        .callGraphQL({
+        values: { dataunit: dataUnit.name, sort, filters },
+        query: this.templateByQuery.get("fetchData"),
+      })
+        .then((resp) => {
+        const result = resp.data;
+        const dataUnitRecords = [];
+        result.records.forEach((responseRecord) => {
+          const duRecord = { __record__id__: responseRecord.id };
+          responseRecord.fields.forEach(({ name, value }) => {
+            duRecord[name] = dataUnit.valueFromString(name, value);
+          });
+          dataUnitRecords.push(duRecord);
+        });
+        resolve(dataUnitRecords);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  saveData(dataUnit, duChanges) {
+    const changes = duChanges.map((change) => {
+      const { dataUnit: changeDU, record, updatingFields, operation } = change;
+      const parsedUpdatingFields = Object.entries(updatingFields).map(([fieldName, value]) => {
+        if (value) {
+          value = value.toString();
+        }
+        return { fieldName, value };
+      });
+      return { dataUnit: changeDU, updatingFields: parsedUpdatingFields, operation, recordId: record.__record__id__ };
+    });
+    return new Promise((resolve, reject) => {
+      HttpFetcher.get()
+        .callGraphQL({
+        values: { changes: changes },
+        query: this.templateByQuery.get("saveData"),
+      })
+        .then((resp) => {
+        const dataUnitRecords = [];
+        resp === null || resp === void 0 ? void 0 : resp.forEach((responseRecord) => {
+          const duRecord = { __record__id__: responseRecord.id };
+          if (responseRecord.oldId) {
+            duRecord.__old__id__ = responseRecord.oldId;
+          }
+          responseRecord.fields.forEach(({ name, value }) => {
+            duRecord[name] = dataUnit.valueFromString(name, value);
+          });
+          dataUnitRecords.push(duRecord);
+        });
+        resolve(dataUnitRecords);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+}

package/dist/collection/lib/http/data-fetcher/fetchers/form-config-fetcher.js

@@ -0,0 +1,2 @@
+export class FormConfigFetcher {
+}

package/dist/collection/lib/http/data-fetcher/fetchers/grid-config-fetcher.js

@@ -0,0 +1,2 @@
+export class GridConfigFetcher {
+}

package/dist/collection/lib/http/data-fetcher/fetchers/parameters-fecher.js

@@ -0,0 +1,59 @@
+import { gql } from "graphql-request";
+import { DateUtils, StringUtils } from "@sankhyalabs/core";
+import { HttpFetcher } from "../DataFetcher";
+export default class ParametersFetcher {
+  constructor() {
+    this.templateByQuery = new Map();
+    this.buldTemplates();
+  }
+  buldTemplates() {
+    this.templateByQuery.set("fetchParam", gql `query($name: String!) {
+            $queryAlias$: fetchResource(name: $name){
+              name
+              resource
+            }
+        }`);
+  }
+  async getParam(name, resourceID) {
+    const completPath = `param://${resourceID}?params=${window.btoa(name)}`;
+    return HttpFetcher.get().callGraphQL({
+      values: { name: completPath },
+      query: this.templateByQuery.get("fetchParam"),
+    });
+  }
+  async asString(name, resourceID) {
+    const paramArr = await this.getParam(name, resourceID);
+    return this.getValue(paramArr);
+  }
+  async asInteger(name, resourceID) {
+    const paramArr = await this.getParam(name, resourceID);
+    return parseInt(this.getValue(paramArr));
+  }
+  async asFloat(name, resourceID) {
+    const paramArr = await this.getParam(name, resourceID);
+    return parseFloat(this.getValue(paramArr));
+  }
+  async asBoolean(name, resourceID) {
+    const paramArr = await this.getParam(name, resourceID);
+    return this.getValue(paramArr) == "S";
+  }
+  async asDate(name, resourceID) {
+    const paramArr = await this.getParam(name, resourceID);
+    return DateUtils.strToDate(this.getValue(paramArr));
+  }
+  async getBatchParams(names, resourceID) {
+    const paramArr = await this.getParam(names.join(","), resourceID);
+    //TODO: try to typed params val?
+    const response = {};
+    paramArr.forEach((param) => (response[param.name] = param.resource));
+    return response;
+  }
+  getValue(obj = {}) {
+    if (Array.isArray(obj) && obj.length > 0) {
+      obj = obj[0];
+    }
+    if (StringUtils.isEmpty(obj.resource))
+      return "";
+    return obj.resource;
+  }
+}

package/dist/collection/lib/http/data-fetcher/state/LoadStateManager.js

@@ -0,0 +1,66 @@
+export class LoadStateManager {
+  constructor(appName = 'snk-application') {
+    this._state = LoadStatus.DOM_LOADED;
+    this._application = document.querySelector(appName);
+    if (this._application === null) {
+      console.warn(`application ${appName} not found, then state is loadded`);
+      this.onStatusChange(LoadStatus.LOADED);
+    }
+    else {
+      this._application.addEventListener('applicationLoaded', () => this.onStatusChange(LoadStatus.LOADED));
+      this._application.addEventListener('applicationLoading', () => this.onStatusChange(LoadStatus.PRE_INITIALIZE));
+      this.onStatusChange(LoadStatus.PRE_INITIALIZE);
+    }
+  }
+  async onStatusChange(newStatus) {
+    this._state = newStatus;
+    (LoadStateManager.listenersByType.get(newStatus) || []).forEach((listener) => {
+      listener();
+    });
+  }
+  addListener(status, listener) {
+    var _a;
+    if (!LoadStateManager.listenersByType.has(status)) {
+      LoadStateManager.listenersByType.set(status, []);
+    }
+    (_a = LoadStateManager.listenersByType.get(status)) === null || _a === void 0 ? void 0 : _a.push(listener);
+    if (status === this._state) {
+      listener();
+    }
+  }
+  onPreInitialize(listener) {
+    this.addListener(LoadStatus.PRE_INITIALIZE, listener);
+    return this;
+  }
+  onLoaded(listener) {
+    this.addListener(LoadStatus.LOADED, listener);
+    return this;
+  }
+  getStatus() {
+    return this._state;
+  }
+  isPreInitialize() {
+    return this._state === LoadStatus.PRE_INITIALIZE;
+  }
+  isLoaded() {
+    return this._state === LoadStatus.LOADED;
+  }
+  static get(type = LoadType.APP_LOAD) {
+    if (!LoadStateManager.instanceByStatus.has(type)) {
+      LoadStateManager.instanceByStatus.set(type, new LoadStateManager());
+    }
+    return LoadStateManager.instanceByStatus.get(type) || new LoadStateManager();
+  }
+}
+LoadStateManager.instanceByStatus = new Map();
+LoadStateManager.listenersByType = new Map();
+export var LoadStatus;
+(function (LoadStatus) {
+  LoadStatus["DOM_LOADED"] = "DOM_LOADED";
+  LoadStatus["PRE_INITIALIZE"] = "PRE_INITIALIZE";
+  LoadStatus["LOADED"] = "LOADED";
+})(LoadStatus || (LoadStatus = {}));
+export var LoadType;
+(function (LoadType) {
+  LoadType["APP_LOAD"] = "APP_LOAD";
+})(LoadType || (LoadType = {}));

package/dist/collection/lib/utils/urlutils.js

@@ -0,0 +1,23 @@
+export default class UrlUtils {
+  static getQueryParams(queryString) {
+    const params = new Map();
+    const re = /[?&]?([^=]+)=([^&]*)/g;
+    let tokens;
+    //Necessário por causa da tela Histórico Padrão que possui resourceID com acento
+    queryString = window.unescape(queryString);
+    queryString = queryString.split("+").join(" ");
+    while ((tokens = re.exec(queryString))) {
+      params.set(window.decodeURIComponent(tokens[1]), tokens[2]);
+    }
+    //Inserimos a urlBase no params.
+    params.set("urlBase", this.getUrlBase());
+    if (window["moduleID"] && window["URIServiceBroker"]) {
+      params.set("moduleID", window["moduleID"]);
+      params.set("URIServiceBroker", window["URIServiceBroker"]);
+    }
+    return params;
+  }
+  static getUrlBase() {
+    return `${location.protocol}"//"${location.hostname}${location.port ? ":" + location.port : ""}`;
+  }
+}

package/dist/collection/lib/workspace/workspace.js

@@ -0,0 +1,7 @@
+export default class Workspace {
+  static openAppActivity(resourceId, pkObject) {
+    var _a;
+    (_a = window["workspace"]) === null || _a === void 0 ? void 0 : _a.openAppActivity(resourceId, pkObject);
+  }
+}
+Workspace.resourceID = window["workspace"].resourceID;

package/dist/collection/temp/ApplicationUtils.js

@@ -0,0 +1,31 @@
+export default class ApplicationUtils {
+  static async showDialog(title, message, icon = null, confirm, critical = false) {
+    return new Promise(resolve => {
+      let dialog = document.querySelector("ez-dialog");
+      if (!dialog) {
+        dialog = document.createElement("ez-dialog");
+        window.document.body.appendChild(dialog);
+      }
+      dialog.show(title, message, critical, confirm, icon).then(ok => resolve(ok));
+    });
+  }
+  static async alert(title, message, icon = null) {
+    return ApplicationUtils.showDialog(title, message, icon, false, false);
+  }
+  static async error(title, message, icon = null) {
+    return ApplicationUtils.showDialog(title, message, icon, false, true);
+  }
+  static async confirm(title, message, icon = null, critical = false) {
+    return ApplicationUtils.showDialog(title, message, icon, true, critical);
+  }
+  static async info(message) {
+    let toast = document.querySelector("ez-toast");
+    if (!toast) {
+      toast = document.createElement("ez-toast");
+      window.document.body.appendChild(toast);
+    }
+    toast.message = message;
+    toast.fadeTime = 4000;
+    toast.show();
+  }
+}

package/dist/components/index.d.ts

@@ -0,0 +1,26 @@
+/* sankhyablocks custom elements */
+
+import type { Components, JSX } from "../types/components";
+
+/**
+ * Used to manually set the base path where assets can be found.
+ * If the script is used as "module", it's recommended to use "import.meta.url",
+ * such as "setAssetPath(import.meta.url)". Other options include
+ * "setAssetPath(document.currentScript.src)", or using a bundler's replace plugin to
+ * dynamically set the path at build time, such as "setAssetPath(process.env.ASSET_PATH)".
+ * But do note that this configuration depends on how your script is bundled, or lack of
+ * bundling, and where your assets can be loaded from. Additionally custom bundling
+ * will have to ensure the static assets are copied to its build directory.
+ */
+export declare const setAssetPath: (path: string) => void;
+
+export interface SetPlatformOptions {
+  raf?: (c: FrameRequestCallback) => number;
+  ael?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+}
+export declare const setPlatformOptions: (opts: SetPlatformOptions) => void;
+
+export type { Components, JSX };
+
+export * from '../types';

package/dist/components/index.js

@@ -0,0 +1 @@
+export { setAssetPath, setPlatformOptions } from '@stencil/core/internal/client';

package/dist/components/snk-application.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface SnkApplication extends Components.SnkApplication, HTMLElement {}
+export const SnkApplication: {
+  prototype: SnkApplication;
+  new (): SnkApplication;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;