@gisce/react-ooui 2.0.0-alpha.62 → 2.0.0-alpha.63

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "@gisce/react-ooui",
-  "version": "2.0.0-alpha.62",
+  "version": "2.0.0-alpha.63",
   "engines": {
     "node": "20.5.0"
   },
+  "packageManager": "npm@9.8.0",
   "publishConfig": {
     "access": "public"
   },
   "files": [
-    "dist",
-    "src",
-    "README.md"
+    "dist"
   ],
   "module": "./dist/react-ooui.es.js",
   "types": "./dist/index.d.ts",
@@ -29,7 +28,7 @@
     "check": "lint-staged",
     "storybook": "storybook dev -p 6006",
     "build-storybook": "storybook build",
-    "analyze": "npm run build && npx vite-bundle-visualizer"
+    "analyze": "npx vite-bundle-visualizer"
   },
   "dependencies": {
     "@ant-design/plots": "^1.0.9",
@@ -44,6 +43,7 @@
     "file-type-buffer-browser": "git+ssh://git@github.com/mguellsegarra/file-type-buffer-browser.git",
     "interweave": "^13.0.0",
     "md5": "^2.3.0",
+    "nanoid": "^5.0.4",
     "react": "18.2.0",
     "react-dom": "18.2.0",
     "react-grid-layout": "^1.3.4",
@@ -53,7 +53,6 @@
     "remark-gfm": "^4.0.0",
     "styled-components": "5.3.5",
     "use-deep-compare-effect": "^1.8.1",
-    "uuid": "^9.0.1",
     "validator": "^13.6.0"
   },
   "devDependencies": {
@@ -81,7 +80,6 @@
     "@types/rollup-plugin-peer-deps-external": "^2.2.2",
     "@types/scroll-into-view": "^1.16.0",
     "@types/styled-components": "^5.1.7",
-    "@types/uuid": "^8.3.1",
     "@types/validator": "^13.6.3",
     "@typescript-eslint/eslint-plugin": "5.59.0",
     "@typescript-eslint/parser": "5.59.0",
@@ -102,7 +100,7 @@
     "semantic-release": "21.0.7",
     "storybook": "^7.4.6",
     "typescript": "^5.0.4",
-    "vite": "4.4.8",
+    "vite": "4.5.1",
     "vite-bundle-visualizer": "^0.10.0",
     "vite-plugin-dts": "^3.6.0",
     "vite-tsconfig-paths": "3.5.0"

package/src/ConnectionProvider.ts

@@ -1,16 +0,0 @@
-import { ConnectionProviderType } from "@/types";
-
-export default class ConnectionProvider {
-  private static handler: ConnectionProviderType;
-
-  public static init(handler: ConnectionProviderType): void {
-    ConnectionProvider.handler = handler;
-  }
-
-  public static getHandler(): ConnectionProviderType {
-    if (!ConnectionProvider.handler) {
-      throw "Must call init() first with a valid ConnectionProvider instance";
-    }
-    return ConnectionProvider.handler;
-  }
-}

package/src/__tests__/iconMapper.test.ts

@@ -1,30 +0,0 @@
-import iconMapper from "../helpers/iconMapper";
-import * as Icons from "@ant-design/icons";
-
-describe("A IconMapper instance", () => {
-  test("should return undefined when key not found", () => {
-    const icon = iconMapper("foo-bar");
-    expect(icon).toBe(undefined);
-  });
-  test("should return proper help icon when requested", () => {
-    const helpIcon = Icons.QuestionOutlined;
-    const icon = iconMapper("gtk-help");
-    expect(icon).toBe(helpIcon);
-  });
-  test("should replace all - for _", () => {
-    const findAndReplaceIcon = Icons.FileSearchOutlined;
-    const icon = iconMapper("gtk-find-and-replace");
-    expect(icon).toBe(findAndReplaceIcon);
-  });
-  test("should return gtk-go", () => {
-    const findAndReplaceIcon = Icons.FileSearchOutlined;
-    const icon = iconMapper("gtk-find-and-replace");
-    expect(icon).toBe(findAndReplaceIcon);
-  });
-  describe("If key doesn't exist in iconMapper", () => {
-    test("should return undefined", () => {
-      const icon = iconMapper("gtk-foo-bar");
-      expect(icon).toBe(undefined);
-    });
-  });
-});

package/src/__tests__/searchFilterHelper.spec.ts

@@ -1,386 +0,0 @@
-import {
-  removeUndefinedFields,
-  groupDateTimeValuesIfNeeded,
-  getParamsForFields,
-} from "../helpers/searchFilterHelper";
-import dayjs from "dayjs";
-
-describe("A SearchFilterHelper instance", () => {
-  describe("removeUndefinedFields method", () => {
-    test("should return the same object without undefined fields", () => {
-      const object = {
-        testField: "field",
-        testField2: undefined,
-        testField3: undefined,
-      };
-
-      const filteredObject = removeUndefinedFields(object);
-
-      expect(Object.keys(filteredObject).length).toBe(1);
-      expect(filteredObject.testField).toBe("field");
-    });
-    test("should return an object without fields", () => {
-      const object = {
-        testField2: undefined,
-        testField3: undefined,
-      };
-
-      const filteredObject = removeUndefinedFields(object);
-
-      expect(Object.keys(filteredObject).length).toBe(0);
-    });
-    test("should return same object if it hasn't any undefined files", () => {
-      const object = {
-        testField1: "field",
-        testField2: "field",
-      };
-
-      const filteredObject = removeUndefinedFields(object);
-
-      expect(Object.keys(filteredObject).length).toBe(2);
-      expect(filteredObject.testField1).toBe("field");
-      expect(filteredObject.testField2).toBe("field");
-    });
-    test("should return an object without fields if we send a null", () => {
-      const object = {
-        testField1: null,
-      };
-
-      const filteredObject = removeUndefinedFields(object);
-      expect(Object.keys(filteredObject).length).toBe(0);
-    });
-    test("should return an object without fields if we send a blank string", () => {
-      const object = {
-        testField1: "",
-      };
-
-      const filteredObject = removeUndefinedFields(object);
-      expect(Object.keys(filteredObject).length).toBe(0);
-    });
-  });
-  describe("groupRangeValues method", () => {
-    test("should return the same object if it hasn't any datetime fields to group", () => {
-      const object = {
-        charValue: "test",
-        floatValue: 0.5,
-      };
-
-      const filteredObject = groupDateTimeValuesIfNeeded(object);
-
-      expect(JSON.stringify(filteredObject)).toBe(JSON.stringify(object));
-    });
-    test("should return a datetime value grouped", () => {
-      const object = {
-        charValue: "test",
-        floatValue: 0.5,
-        "dateField#date": [dayjs("2021-01-01"), dayjs("2021-01-02")],
-        "dateField#time": [
-          dayjs("1970-01-01 00:00"),
-          dayjs("1970-01-01 04:00"),
-        ],
-      };
-
-      const filteredObject = groupDateTimeValuesIfNeeded(object);
-
-      expect(Object.keys(filteredObject).length).toBe(3);
-      expect(Object.keys(filteredObject)).toContain("dateField#datetime");
-      expect(filteredObject.charValue).toBe(object.charValue);
-      expect(filteredObject.floatValue).toBe(object.floatValue);
-      expect(Array.isArray(filteredObject["dateField#datetime"])).toBeTruthy();
-      const from = filteredObject["dateField#datetime"][0];
-      const to = filteredObject["dateField#datetime"][1];
-      expect(from).toBe("2021-01-01 00:00");
-      expect(to).toBe("2021-01-02 04:00");
-    });
-  });
-  describe("getParamsForField method", () => {
-    test("should return properly a float parameter", () => {
-      const fields = {
-        floatType: {
-          type: "float",
-        },
-      };
-      const values = {
-        "floatType#from": 1.1,
-        "floatType#to": 1.5,
-      };
-      const params = getParamsForFields(values, fields);
-      expect(Array.isArray(params)).toBeTruthy();
-      expect(params.length).toBe(2);
-      expect(Array.isArray(params[0])).toBeTruthy();
-      expect(params[0].length).toBe(3);
-      const from = params[0];
-      const to = params[1];
-      expect(Array.isArray(from)).toBeTruthy();
-      expect(Array.isArray(to)).toBeTruthy();
-      expect(from[0]).toBe("floatType");
-      expect(to[0]).toBe("floatType");
-      expect(from[1]).toBe(">=");
-      expect(to[1]).toBe("<=");
-      expect(from[2]).toBe(1.1);
-      expect(to[2]).toBe(1.5);
-    });
-    test("should return properly a float_time parameter", () => {
-      const fields = {
-        floatType: {
-          type: "float_time",
-        },
-      };
-      const values = {
-        "floatType#from": 1.1,
-        "floatType#to": 1.5,
-      };
-      const params = getParamsForFields(values, fields);
-      expect(Array.isArray(params)).toBeTruthy();
-      expect(params.length).toBe(2);
-      expect(Array.isArray(params[0])).toBeTruthy();
-      expect(params[0].length).toBe(3);
-      const from = params[0];
-      const to = params[1];
-      expect(Array.isArray(from)).toBeTruthy();
-      expect(Array.isArray(to)).toBeTruthy();
-      expect(from[0]).toBe("floatType");
-      expect(to[0]).toBe("floatType");
-      expect(from[1]).toBe(">=");
-      expect(to[1]).toBe("<=");
-      expect(from[2]).toBe(1.1);
-      expect(to[2]).toBe(1.5);
-    });
-    test("should return properly a progressbar parameter", () => {
-      const fields = {
-        floatType: {
-          type: "progressbar",
-        },
-      };
-      const values = {
-        "floatType#from": 1.1,
-        "floatType#to": 1.5,
-      };
-      const params = getParamsForFields(values, fields);
-      expect(Array.isArray(params)).toBeTruthy();
-      expect(params.length).toBe(2);
-      expect(Array.isArray(params[0])).toBeTruthy();
-      expect(params[0].length).toBe(3);
-      const from = params[0];
-      const to = params[1];
-      expect(Array.isArray(from)).toBeTruthy();
-      expect(Array.isArray(to)).toBeTruthy();
-      expect(from[0]).toBe("floatType");
-      expect(to[0]).toBe("floatType");
-      expect(from[1]).toBe(">=");
-      expect(to[1]).toBe("<=");
-      expect(from[2]).toBe(1.1);
-      expect(to[2]).toBe(1.5);
-    });
-    test("should return properly an integer parameter", () => {
-      const fields = {
-        field: {
-          type: "integer",
-        },
-      };
-      const values = {
-        "field#from": 1,
-        "field#to": 5,
-      };
-      const params = getParamsForFields(values, fields);
-      expect(Array.isArray(params)).toBeTruthy();
-      expect(params.length).toBe(2);
-      expect(Array.isArray(params[0])).toBeTruthy();
-      expect(params[0].length).toBe(3);
-      const from = params[0];
-      const to = params[1];
-      expect(Array.isArray(from)).toBeTruthy();
-      expect(Array.isArray(to)).toBeTruthy();
-      expect(from[0]).toBe("field");
-      expect(to[0]).toBe("field");
-      expect(from[1]).toBe(">=");
-      expect(to[1]).toBe("<=");
-      expect(from[2]).toBe(1);
-      expect(to[2]).toBe(5);
-    });
-    test("should return properly an char parameter", () => {
-      const fields = {
-        field: {
-          type: "char",
-        },
-      };
-      const values = {
-        field: "lorem ipsum",
-      };
-      const params = getParamsForFields(values, fields);
-      expect(Array.isArray(params)).toBeTruthy();
-      expect(params.length).toBe(1);
-      expect(Array.isArray(params[0])).toBeTruthy();
-      expect(params[0].length).toBe(3);
-      const fieldParams = params[0];
-      expect(fieldParams[0]).toBe("field");
-      expect(fieldParams[1]).toBe("ilike");
-      expect(fieldParams[2]).toBe("lorem ipsum");
-    });
-    test("should return properly a text parameter", () => {
-      const fields = {
-        field: {
-          type: "text",
-        },
-      };
-      const values = {
-        field: "lorem ipsum",
-      };
-      const params = getParamsForFields(values, fields);
-      expect(Array.isArray(params)).toBeTruthy();
-      expect(params.length).toBe(1);
-      expect(Array.isArray(params[0])).toBeTruthy();
-      expect(params[0].length).toBe(3);
-      const fieldParams = params[0];
-      expect(fieldParams[0]).toBe("field");
-      expect(fieldParams[1]).toBe("ilike");
-      expect(fieldParams[2]).toBe("lorem ipsum");
-    });
-    test("should return properly a many2one parameter", () => {
-      const fields = {
-        field: {
-          type: "many2one",
-        },
-      };
-      const values = {
-        field: "lorem ipsum",
-      };
-      const params = getParamsForFields(values, fields);
-      expect(Array.isArray(params)).toBeTruthy();
-      expect(params.length).toBe(1);
-      expect(Array.isArray(params[0])).toBeTruthy();
-      expect(params[0].length).toBe(3);
-      const fieldParams = params[0];
-      expect(fieldParams[0]).toBe("field");
-      expect(fieldParams[1]).toBe("ilike");
-      expect(fieldParams[2]).toBe("lorem ipsum");
-    });
-    test("should return properly a one2many parameter", () => {
-      const fields = {
-        field: {
-          type: "one2many",
-        },
-      };
-      const values = {
-        field: "lorem ipsum",
-      };
-      const params = getParamsForFields(values, fields);
-      expect(Array.isArray(params)).toBeTruthy();
-      expect(params.length).toBe(1);
-      expect(Array.isArray(params[0])).toBeTruthy();
-      expect(params[0].length).toBe(3);
-      const fieldParams = params[0];
-      expect(fieldParams[0]).toBe("field");
-      expect(fieldParams[1]).toBe("ilike");
-      expect(fieldParams[2]).toBe("lorem ipsum");
-    });
-    test("should return properly a many2many parameter", () => {
-      const fields = {
-        field: {
-          type: "many2many",
-        },
-      };
-      const values = {
-        field: "lorem ipsum",
-      };
-      const params = getParamsForFields(values, fields);
-      expect(Array.isArray(params)).toBeTruthy();
-      expect(params.length).toBe(1);
-      expect(Array.isArray(params[0])).toBeTruthy();
-      expect(params[0].length).toBe(3);
-      const fieldParams = params[0];
-      expect(fieldParams[0]).toBe("field");
-      expect(fieldParams[1]).toBe("ilike");
-      expect(fieldParams[2]).toBe("lorem ipsum");
-    });
-    test("should return properly a selection parameter", () => {
-      const fields = {
-        field: {
-          type: "selection",
-        },
-      };
-      const values = {
-        field: "value",
-      };
-      const params = getParamsForFields(values, fields);
-      expect(Array.isArray(params)).toBeTruthy();
-      expect(params.length).toBe(1);
-      expect(Array.isArray(params[0])).toBeTruthy();
-      expect(params[0].length).toBe(3);
-      const fieldParams = params[0];
-      expect(fieldParams[0]).toBe("field");
-      expect(fieldParams[1]).toBe("=");
-      expect(fieldParams[2]).toBe("value");
-    });
-    test("should return properly a boolean parameter", () => {
-      const fields = {
-        field: {
-          type: "boolean",
-        },
-      };
-      const values = {
-        field: "true",
-      };
-      const params = getParamsForFields(values, fields);
-      expect(Array.isArray(params)).toBeTruthy();
-      expect(params.length).toBe(1);
-      expect(Array.isArray(params[0])).toBeTruthy();
-      expect(params[0].length).toBe(3);
-      const fieldParams = params[0];
-      expect(fieldParams[0]).toBe("field");
-      expect(fieldParams[1]).toBe("=");
-      expect(fieldParams[2]).toBe(true);
-    });
-    test("should return properly a date parameter", () => {
-      const fields = {
-        field: {
-          type: "date",
-        },
-      };
-      const values = {
-        field: [dayjs("2021-01-01"), dayjs("2021-01-02")],
-      };
-      const params = getParamsForFields(values, fields);
-      expect(Array.isArray(params)).toBeTruthy();
-      expect(params.length).toBe(2);
-      expect(Array.isArray(params[0])).toBeTruthy();
-      expect(params[0].length).toBe(3);
-      const from = params[0];
-      const to = params[1];
-      expect(Array.isArray(from)).toBeTruthy();
-      expect(Array.isArray(to)).toBeTruthy();
-      expect(from[0]).toBe("field");
-      expect(to[0]).toBe("field");
-      expect(from[1]).toBe(">=");
-      expect(to[1]).toBe("<=");
-      expect(from[2]).toBe("2021-01-01");
-      expect(to[2]).toBe("2021-01-02");
-    });
-    test("should return properly a datetime parameter", () => {
-      const fields = {
-        field: {
-          type: "datetime",
-        },
-      };
-      const values = {
-        "field#date": [dayjs("2021-01-01"), dayjs("2021-01-02")],
-        "field#time": [dayjs("1970-01-01 03:31"), dayjs("1970-01-01 03:32")],
-      };
-      const params = getParamsForFields(values, fields);
-      expect(Array.isArray(params)).toBeTruthy();
-      expect(params.length).toBe(2);
-      expect(Array.isArray(params[0])).toBeTruthy();
-      expect(params[0].length).toBe(3);
-      const from = params[0];
-      const to = params[1];
-      expect(Array.isArray(from)).toBeTruthy();
-      expect(Array.isArray(to)).toBeTruthy();
-      expect(from[0]).toBe("field");
-      expect(to[0]).toBe("field");
-      expect(from[1]).toBe(">=");
-      expect(to[1]).toBe("<=");
-      expect(from[2]).toBe("2021-01-01 03:31");
-      expect(to[2]).toBe("2021-01-02 03:32");
-    });
-  });
-});

package/src/actionbar/ActionButton.tsx

@@ -1,40 +0,0 @@
-import React from "react";
-import ButtonWithTooltip from "@/common/ButtonWithTooltip";
-import { LoadingOutlined } from "@ant-design/icons";
-
-type Props = {
-  tooltip: string;
-  onClick: any;
-  icon: any;
-  disabled?: boolean;
-  label?: string;
-  loading?: boolean;
-  type?: string;
-};
-
-function ActionButton(props: Props) {
-  const {
-    onClick,
-    disabled = false,
-    loading = false,
-    tooltip,
-    icon,
-    label,
-    type = "default",
-  } = props;
-  const finalIcon = loading ? <LoadingOutlined /> : icon;
-
-  return (
-    <ButtonWithTooltip
-      type={type as any}
-      tooltip={tooltip}
-      onClick={onClick}
-      disabled={disabled}
-    >
-      {finalIcon}
-      {label}
-    </ButtonWithTooltip>
-  );
-}
-
-export default ActionButton;

package/src/actionbar/AttachmentsButton.tsx

@@ -1,132 +0,0 @@
-import React, { useCallback, useContext, useEffect, useState } from "react";
-import { getMimeType, openBase64InNewTab } from "@/helpers/filesHelper";
-import ConnectionProvider from "@/ConnectionProvider";
-import {
-  ActionViewContext,
-  ActionViewContextType,
-} from "@/context/ActionViewContext";
-import showErrorDialog from "@/ui/ActionErrorDialog";
-import {
-  Attachment,
-  AttachmentsButtonWrapper,
-} from "./AttachmentsButtonWrapper";
-import { Modal, Spin } from "antd";
-import { LocaleContext, LocaleContextType } from "@/context/LocaleContext";
-
-export type AttachmentsButtonProps = {
-  attachments?: any;
-  disabled?: boolean;
-  onAddNewAttachment: () => void;
-  onListAllAttachments: () => void;
-  onViewAttachmentDetails: (attachment: Attachment) => void;
-};
-
-function AttachmentsButton(props: AttachmentsButtonProps) {
-  const {
-    attachments,
-    disabled = false,
-    onAddNewAttachment,
-    onListAllAttachments,
-    onViewAttachmentDetails,
-  } = props;
-  const { formRef } = useContext(ActionViewContext) as ActionViewContextType;
-  const [preloading, setPreloading] = useState(false);
-  const [preloadedAttachments, setPreloadedAttachments] = useState<
-    Attachment[]
-  >([]);
-  const [downloading, setDownloading] = useState(false);
-  const { t } = useContext(LocaleContext) as LocaleContextType;
-
-  const preloadAttachments = useCallback(async () => {
-    setPreloading(true);
-    try {
-      const results = await ConnectionProvider.getHandler().readObjects({
-        model: "ir.attachment",
-        ids: attachments.map((a: any) => a.id),
-        fieldsToRetrieve: ["name", "datas_fname", "link"],
-        context: (formRef.current as any).getContext(),
-      });
-      setPreloadedAttachments(
-        results.map((r: any) => ({
-          id: r.id,
-          name: r.name,
-          datas_fname: r.datas_fname,
-          link: r.link,
-        })),
-      );
-    } catch (error) {
-      showErrorDialog(error as any);
-    }
-    setPreloading(false);
-  }, attachments);
-
-  const openAttachmentLink = useCallback(async (attachment: any) => {
-    if (attachment.link) {
-      window.open(attachment.link);
-      return;
-    }
-
-    setDownloading(true);
-
-    let retrievedAttachment;
-
-    try {
-      const results = await ConnectionProvider.getHandler().readObjects({
-        model: "ir.attachment",
-        ids: [attachment.id],
-        context: (formRef.current as any).getContext(),
-      });
-      retrievedAttachment = results[0];
-    } catch (error) {
-      showErrorDialog(error as any);
-    }
-
-    setDownloading(false);
-
-    if (!retrievedAttachment) {
-      return;
-    }
-
-    if (retrievedAttachment.datas) {
-      const fileType: any = await getMimeType(retrievedAttachment.datas);
-      openBase64InNewTab(retrievedAttachment.datas, fileType.mime);
-    } else {
-      onViewAttachmentDetails(retrievedAttachment);
-    }
-  }, []);
-
-  const openAttachmentDetail = useCallback(async (attachment: any) => {
-    onViewAttachmentDetails(attachment);
-  }, []);
-
-  useEffect(() => {
-    preloadAttachments();
-  }, [preloadAttachments]);
-
-  return (
-    <>
-      <AttachmentsButtonWrapper
-        numberOfAttachments={attachments.length}
-        attachments={preloadedAttachments}
-        disabled={disabled}
-        loading={preloading}
-        onAddNewAttachment={onAddNewAttachment}
-        onListAllAttachments={onListAllAttachments}
-        onopenAttachmentLink={openAttachmentLink}
-        onOpenAttachmentDetail={openAttachmentDetail}
-      />
-      <Modal
-        title={t("downloadingAttachment")}
-        open={downloading}
-        footer={null}
-        closable={false}
-        centered
-        maskClosable={false}
-      >
-        <Spin />
-      </Modal>
-    </>
-  );
-}
-
-export default AttachmentsButton;