@vanillabp/bc-shared 0.0.3

package/dist/utils/now-hook.d.ts

@@ -0,0 +1,7 @@
+declare let now: Date;
+declare type EachSecondHook = (lastNow: Date) => void;
+declare const useKeepNowUpToDate: () => void;
+declare const registerEachSecondHook: (eachSecondHook: EachSecondHook) => void;
+declare const unregisterEachSecondHook: (eachSecondHook: EachSecondHook) => void;
+
+export { now, registerEachSecondHook, unregisterEachSecondHook, useKeepNowUpToDate };

package/dist/utils/now-hook.js

@@ -0,0 +1,30 @@
+import "../chunk-YH4NJHER.js";
+import { useEffect } from "react";
+let now = /* @__PURE__ */ new Date();
+const hooks = new Array();
+const useKeepNowUpToDate = () => {
+  useEffect(() => {
+    const timer = window.setInterval(() => {
+      now = /* @__PURE__ */ new Date();
+      hooks.forEach((hook) => {
+        const lastNow = hook.lastNow;
+        hook.lastNow = now;
+        hook.hook(lastNow);
+      });
+    }, 1e3);
+    return () => window.clearInterval(timer);
+  }, []);
+};
+const registerEachSecondHook = (eachSecondHook) => {
+  hooks.push({ hook: eachSecondHook, lastNow: now });
+};
+const unregisterEachSecondHook = (eachSecondHook) => {
+  const hookIndex = hooks.findIndex((hook) => hook.hook === eachSecondHook);
+  hooks.splice(hookIndex, 1);
+};
+export {
+  now,
+  registerEachSecondHook,
+  unregisterEachSecondHook,
+  useKeepNowUpToDate
+};

package/dist/utils/objectUtils.d.ts

@@ -0,0 +1,5 @@
+declare const getObjectProperty: (object: any, path: string, defaultValue?: string) => any | undefined;
+declare const mergeTwoSortedArrays: <T>(array1: T[], array2: T[], compare?: (first: T, second: T) => boolean) => T[];
+declare const keepOldItemsInArray: <T>(newArray: T[], oldArray: T[], getId?: (item: T) => any, map?: (newItem: T | undefined, oldItem: T | undefined, index: number) => T, isFirstBeforeSecond?: (first: T, second: T) => boolean) => T[];
+
+export { getObjectProperty, keepOldItemsInArray, mergeTwoSortedArrays };

package/dist/utils/objectUtils.js

@@ -0,0 +1,95 @@
+import "../chunk-YH4NJHER.js";
+const getObjectProperty = (object, path, defaultValue) => {
+  if (!Boolean(object)) {
+    return defaultValue;
+  }
+  const parts = path.split(".");
+  return parts.reduce((object2, key) => object2 == null ? void 0 : object2[key], object);
+};
+const mergeTwoSortedArrays = (array1, array2, compare = (f, s) => f < s) => {
+  let merged = [];
+  let index1 = 0;
+  let index2 = 0;
+  let current = 0;
+  while (current < array1.length + array2.length) {
+    let isArr1Depleted = index1 >= array1.length;
+    let isArr2Depleted = index2 >= array2.length;
+    if (!isArr1Depleted && (isArr2Depleted || compare(array1[index1], array2[index2]))) {
+      merged[current] = array1[index1];
+      index1++;
+    } else {
+      merged[current] = array2[index2];
+      index2++;
+    }
+    current++;
+  }
+  return merged;
+};
+const keepOldItemsInArray = (newArray, oldArray, getId = (item) => item, map = (i, oi, idx) => i || oi, isFirstBeforeSecond = (f, s) => f < s) => {
+  let merged = [];
+  let indexNew = 0;
+  let indexOld = 0;
+  while (indexNew < newArray.length || indexOld < oldArray.length) {
+    if (indexNew < newArray.length) {
+      let idOfNewItem = getId(newArray[indexNew]);
+      let toBeMerged = indexOld;
+      while (toBeMerged < oldArray.length && getId(oldArray[toBeMerged]) !== idOfNewItem) {
+        ++toBeMerged;
+      }
+      if (toBeMerged < oldArray.length) {
+        while (indexOld < toBeMerged) {
+          merged.push(map(void 0, oldArray[indexOld], merged.length));
+          ++indexOld;
+        }
+        if (indexOld < oldArray.length) {
+          merged.push(map(newArray[indexNew], oldArray[indexOld], merged.length));
+          ++indexOld;
+        }
+        ++indexNew;
+      } else {
+        let lookAheadIndexNew = indexNew + 1;
+        toBeMerged = indexOld;
+        while (lookAheadIndexNew < newArray.length) {
+          idOfNewItem = getId(newArray[lookAheadIndexNew]);
+          while (toBeMerged < oldArray.length && getId(oldArray[toBeMerged]) !== idOfNewItem) {
+            ++toBeMerged;
+          }
+          if (toBeMerged != oldArray.length) {
+            lookAheadIndexNew = newArray.length;
+          } else {
+            toBeMerged = indexOld;
+          }
+          ++lookAheadIndexNew;
+        }
+        while (indexOld < toBeMerged) {
+          if (isFirstBeforeSecond(oldArray[indexOld], newArray[indexNew])) {
+            merged.push(map(void 0, oldArray[indexOld], merged.length));
+            ++indexOld;
+          } else {
+            toBeMerged = indexOld;
+          }
+        }
+        if (idOfNewItem !== void 0) {
+          if (indexOld < oldArray.length && isFirstBeforeSecond(oldArray[indexOld], newArray[indexNew])) {
+            merged.push(map(void 0, oldArray[indexOld], merged.length));
+            ++indexOld;
+          } else {
+            merged.push(map(newArray[indexNew], void 0, merged.length));
+            ++indexNew;
+          }
+        } else {
+          ++indexNew;
+        }
+      }
+    } else {
+      merged.push(map(void 0, oldArray[indexOld], merged.length));
+      ++indexOld;
+    }
+  }
+  return merged;
+};
+export {
+  getObjectProperty,
+  keepOldItemsInArray,
+  mergeTwoSortedArrays
+};

package/dist/utils/responsiveUtils.d.ts

@@ -0,0 +1,13 @@
+declare type Screen = 'phone' | 'tablet' | 'computer';
+declare type CurrentScreen = {
+    isPhone: boolean;
+    isNotPhone: boolean;
+    isTablet: boolean;
+    isNotTablet: boolean;
+    isComputer: boolean;
+    isNotComputer: boolean;
+    currentScreen: Screen;
+};
+declare const useResponsiveScreen: () => CurrentScreen;
+
+export { useResponsiveScreen };

package/dist/utils/responsiveUtils.js

@@ -0,0 +1,18 @@
+import "../chunk-YH4NJHER.js";
+import { ResponsiveContext } from "grommet";
+import { useContext } from "react";
+const useResponsiveScreen = () => {
+  const size = useContext(ResponsiveContext);
+  return {
+    isPhone: size === "small",
+    isNotPhone: size !== "small",
+    isTablet: size === "medium",
+    isNotTablet: size !== "medium",
+    isComputer: size === "large",
+    isNotComputer: size !== "large",
+    currentScreen: size === "small" ? "phone" : size === "medium" ? "tablet" : "computer"
+  };
+};
+export {
+  useResponsiveScreen
+};

package/dist/utils/timeUtils.d.ts

@@ -0,0 +1,14 @@
+declare const isValidLocalDate: (localDate: string) => boolean;
+declare const parseLocalDate: (localDate: string | undefined) => Date | undefined;
+declare const parseLocalDateToIsoString: (localDate: string | undefined | null) => string | undefined;
+declare const toLocalDateString: (date?: Date) => string | undefined;
+declare const toLocaleTimeStringWithoutSeconds: (date?: Date) => string | undefined;
+declare const toLocaleDateString: (date?: Date) => string | undefined;
+declare const toLocaleStringWithoutSeconds: (date?: Date) => string | undefined;
+declare const currentHour: () => Date;
+declare const nextHours: (from: Date, hours: number, history: boolean) => Date;
+declare const hoursBetween: (from: Date, to: Date) => Array<Date>;
+declare const numberOfHoursBetween: (from: Date, to: Date) => number;
+declare const timeAsString: (date: Date) => string;
+
+export { currentHour, hoursBetween, isValidLocalDate, nextHours, numberOfHoursBetween, parseLocalDate, parseLocalDateToIsoString, timeAsString, toLocalDateString, toLocaleDateString, toLocaleStringWithoutSeconds, toLocaleTimeStringWithoutSeconds };

package/dist/utils/timeUtils.js

@@ -0,0 +1,107 @@
+import "../chunk-YH4NJHER.js";
+const LOCAL_DATE_FORMAT = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/;
+const isValidLocalDate = (localDate) => {
+  try {
+    parseLocalDate(localDate);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+const parseLocalDate = (localDate) => {
+  if (!Boolean(localDate)) {
+    return void 0;
+  }
+  const result = localDate.match(LOCAL_DATE_FORMAT);
+  if (result == null) {
+    throw new Error(`Unsupported date format '${localDate}'`);
+  }
+  const year = parseInt(result[1]);
+  const month = parseInt(result[2]) - 1;
+  const day = parseInt(result[3]);
+  return new Date(year, month, day);
+};
+const parseLocalDateToIsoString = (localDate) => {
+  if (!Boolean(localDate)) {
+    return void 0;
+  }
+  return new Date(localDate).toISOString();
+};
+const toLocalDateString = (date) => {
+  if (!Boolean(date)) {
+    return void 0;
+  }
+  return String(date.getFullYear()).padStart(4, "0") + "-" + String(date.getMonth() + 1).padStart(2, "0") + "-" + String(date.getDate()).padStart(2, "0");
+};
+const toLocaleTimeStringWithoutSeconds = (date) => {
+  if (!Boolean(date)) {
+    return void 0;
+  }
+  return date.toLocaleTimeString(window.navigator.language).replace(/:[0-9]{2}(?: |$)/, "");
+};
+const toLocaleDateString = (date) => {
+  if (!Boolean(date)) {
+    return void 0;
+  }
+  return date.toLocaleDateString(window.navigator.language);
+};
+const toLocaleStringWithoutSeconds = (date) => {
+  if (!Boolean(date)) {
+    return void 0;
+  }
+  return `${toLocaleDateString(date)} ${toLocaleTimeStringWithoutSeconds(date)}`;
+};
+const currentHour = () => {
+  const now = /* @__PURE__ */ new Date();
+  return new Date(
+    now.getFullYear(),
+    now.getMonth(),
+    now.getDate(),
+    now.getHours()
+  );
+};
+const nextHours = (from, hours, history) => {
+  return new Date(
+    from.getFullYear(),
+    from.getMonth(),
+    from.getDate(),
+    from.getHours() + hours * (history ? -1 : 1)
+  );
+};
+const hoursBetween = (from, to) => {
+  const result = [];
+  let current = new Date(
+    from.getFullYear(),
+    from.getMonth(),
+    from.getDate(),
+    from.getHours()
+  );
+  if (current.getTime() < from.getTime()) {
+    current = new Date(current.getTime() + 36e5);
+  }
+  while (current.getTime() < to.getTime()) {
+    result.push(current);
+    current = new Date(current.getTime() + 36e5);
+  }
+  return result;
+};
+const numberOfHoursBetween = (from, to) => {
+  return Math.abs(from.getTime() - to.getTime()) / 36e5;
+};
+const timeAsString = (date) => {
+  return String(date.getHours()).padStart(2, "0") + ":" + String(date.getMinutes()).padStart(2, "0");
+};
+export {
+  currentHour,
+  hoursBetween,
+  isValidLocalDate,
+  nextHours,
+  numberOfHoursBetween,
+  parseLocalDate,
+  parseLocalDateToIsoString,
+  timeAsString,
+  toLocalDateString,
+  toLocaleDateString,
+  toLocaleStringWithoutSeconds,
+  toLocaleTimeStringWithoutSeconds
+};

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@vanillabp/bc-shared",
+  "version": "0.0.3",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vanillabp/business-cockpit.git"
+  },
+  "homepage": "https://github.com/vanillabp/business-cockpit",
+  "sideEffects": false,
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "dependencies": {
+    "@microsoft/fetch-event-source": "2.0.1",
+    "@vanillabp/bc-official-gui-client": "0.0.3",
+    "react-cookie": "4.1.1",
+    "usehooks-ts": "2.7.1"
+  },
+  "peerDependencies": {
+    "@fontsource/roboto": "4.5.8",
+    "grommet": "2.33.2",
+    "grommet-icons": "4.10.0",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
+    "react-jsx": "1.0.0",
+    "styled-components": "5.3.3"
+  },
+  "optionalDependencies": {
+    "i18next": "22.0.3",
+    "react-i18next": "12.0.0"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "7.21.4",
+    "@babel/preset-react": "7.18.6",
+    "@babel/preset-typescript": "7.21.4",
+    "@storybook/addon-essentials": "7.0.6",
+    "@storybook/addon-interactions": "7.0.6",
+    "@storybook/addon-links": "7.0.6",
+    "@storybook/blocks": "7.0.6",
+    "@storybook/react": "7.0.6",
+    "@storybook/react-webpack5": "7.0.6",
+    "@storybook/testing-library": "0.0.14-next.2",
+    "@types/jest": "^29.5.11",
+    "@types/node": "16.18.23",
+    "@types/react": "18.0.21",
+    "@types/react-dom": "18.0.6",
+    "@types/styled-components": "5.1.24",
+    "@types/web": "0.0.61",
+    "cross-env": "7.0.3",
+    "http-proxy-middleware": "2.0.6",
+    "jest": "^29.7.0",
+    "prop-types": "15.8.1",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
+    "storybook": "7.0.6",
+    "ts-jest": "^29.1.1",
+    "tsup": "6.7.0",
+    "typescript": "4.8.4"
+  },
+  "scripts": {
+    "storybook": "echo 'Run with sudo on Linux for HMR!' && storybook dev -p 6006",
+    "build-storybook": "storybook build",
+    "start": "tsup --watch",
+    "build": "tsup",
+    "test": "jest",
+    "unpublish:snapshot": "npm unpublish --force",
+    "publish:snapshot": "npm publish --tag snapshot",
+    "version:snapshot": "npm version ${npm_config_newversion} --no-git-tag-version",
+    "publish:release": "npm publish --access public"
+  }
+}