@followupus/common 0.0.2 → 0.2.0

package/README.md

@@ -1 +1,15 @@
-# common
+# common
+
+## add a changelog after some modifications
+```sh
+pnpm changeset
+```
+
+## publish package
+
+update the `version` property in package.json
+
+```sh
+pnpm version
+pnpm release
+```

package/dist/index.d.ts

@@ -1 +1,3 @@
 export declare const myPackage: (taco?: string) => string;
+export * from "./shared/index";
+export * from "./utils";

package/dist/index.js

@@ -1 +1,3 @@
-export const myPackage = (taco = '') => `${taco} from my  package`;
+export const myPackage = (taco = '') => `${taco} from my package`;
+export * from "./shared/index";
+export * from "./utils";

package/dist/shared/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./shared";
+export * from "./types";

package/dist/shared/index.js

@@ -0,0 +1,2 @@
+export * from "./shared";
+export * from "./types";

package/dist/shared/shared.d.ts

@@ -0,0 +1,51 @@
+import { IBaseCustomColumn, IBaseGroup, IFilter, IFilterCondition, IPureBoard } from "./types";
+export declare const COLUMN_TYPES: {
+    NUMBER: string;
+    TEXT: string;
+    DROPDOWN: string;
+    DATE: string;
+    STATUS: string;
+    PRIORITY: string;
+    LINK: string;
+    TAGS: string;
+    EMAIL: string;
+    PEOPLE: string;
+    LINKED_COLUMN: string;
+    REF_LINED_COLUMN: string;
+    FILES: string;
+    HOURS: string;
+    TIMELINE: string;
+    PHONE: string;
+    CURRENCY: string;
+};
+export declare const OP_TYPES: {
+    CONTAINS: string;
+    NOT_CONTAINS: string;
+    IS: string;
+    IS_NOT: string;
+    EMPTY: string;
+    NOT_EMPTY: string;
+    EQUAL: string;
+    GREATER: string;
+    GREATER_EQUAL: string;
+    NOT_EQUAL: string;
+    LESS_EQUAL: string;
+    LESS: string;
+};
+export declare const COLUMN_OP_TYPES: {
+    [x: string]: string[];
+};
+export declare const DATE_GROUPS: {
+    OVERDUE: string;
+    TODAY: string;
+    TOMORROW: string;
+    THIS_WEEK: string;
+    NEXT_WEEK: string;
+    THIS_MONTH: string;
+    FUTURE: string;
+};
+export declare const getColumnValueType: (columnType: string) => "string" | "number" | "object" | "stringArray" | "objectArray";
+export declare const getDateGroupKey: (dateStr: string) => string | null;
+export declare const getValidConditions: (filter: IFilter, headers?: IBaseCustomColumn[]) => IFilterCondition[];
+export declare const filterItemsByConditions: (groups: IBaseGroup[], filter: IFilter, headers?: IBaseCustomColumn[]) => IBaseGroup[];
+export declare const filterBoardTree: (board: IPureBoard, filter: IFilter) => IPureBoard;

package/dist/shared/shared.js

@@ -0,0 +1,392 @@
+import { isEqual } from "lodash";
+import dayjs from "dayjs";
+export const COLUMN_TYPES = {
+    NUMBER: "number",
+    TEXT: "string",
+    DROPDOWN: "dropdown",
+    DATE: "date",
+    STATUS: "status",
+    PRIORITY: "priority",
+    LINK: "link",
+    TAGS: "tags",
+    EMAIL: "email",
+    PEOPLE: "people",
+    LINKED_COLUMN: "linked_column",
+    REF_LINED_COLUMN: "ref_linked_column",
+    FILES: "files",
+    HOURS: "hours",
+    TIMELINE: "timeline",
+    PHONE: "phone",
+    CURRENCY: "currency",
+};
+export const OP_TYPES = {
+    CONTAINS: "like",
+    NOT_CONTAINS: "not_like",
+    IS: "in",
+    IS_NOT: "not_in",
+    EMPTY: "empty",
+    NOT_EMPTY: "not_empty",
+    EQUAL: "eq",
+    GREATER: "gt",
+    GREATER_EQUAL: "gte",
+    NOT_EQUAL: "neq",
+    LESS_EQUAL: "lte",
+    LESS: "lt",
+};
+export const COLUMN_OP_TYPES = {
+    [COLUMN_TYPES.TEXT]: [
+        OP_TYPES.CONTAINS,
+        OP_TYPES.NOT_CONTAINS,
+        OP_TYPES.IS,
+        OP_TYPES.IS_NOT,
+    ],
+    [COLUMN_TYPES.DATE]: [
+        OP_TYPES.IS,
+        OP_TYPES.IS_NOT,
+        OP_TYPES.EMPTY,
+        OP_TYPES.NOT_EMPTY,
+    ],
+    [COLUMN_TYPES.NUMBER]: [
+        OP_TYPES.EQUAL,
+        OP_TYPES.NOT_EQUAL,
+        OP_TYPES.GREATER,
+        OP_TYPES.GREATER_EQUAL,
+        OP_TYPES.LESS,
+        OP_TYPES.LESS_EQUAL,
+        OP_TYPES.EMPTY,
+        OP_TYPES.NOT_EMPTY,
+    ],
+    [COLUMN_TYPES.DROPDOWN]: [
+        OP_TYPES.IS,
+        OP_TYPES.IS_NOT,
+        OP_TYPES.EMPTY,
+        OP_TYPES.NOT_EMPTY,
+    ],
+    [COLUMN_TYPES.STATUS]: [
+        OP_TYPES.IS,
+        OP_TYPES.IS_NOT,
+        OP_TYPES.EMPTY,
+        OP_TYPES.NOT_EMPTY,
+    ],
+    [COLUMN_TYPES.PRIORITY]: [
+        OP_TYPES.IS,
+        OP_TYPES.IS_NOT,
+        OP_TYPES.EMPTY,
+        OP_TYPES.NOT_EMPTY,
+    ],
+    [COLUMN_TYPES.PEOPLE]: [
+        OP_TYPES.IS,
+        OP_TYPES.IS_NOT,
+        OP_TYPES.EMPTY,
+        OP_TYPES.NOT_EMPTY,
+    ],
+};
+export const DATE_GROUPS = {
+    OVERDUE: "overdue",
+    TODAY: "today",
+    TOMORROW: "tomorrow",
+    THIS_WEEK: "thisWeek",
+    NEXT_WEEK: "nextWeek",
+    THIS_MONTH: "thisMonth",
+    FUTURE: "future",
+};
+export const getColumnValueType = (columnType) => {
+    switch (columnType) {
+        case COLUMN_TYPES.PEOPLE:
+        case COLUMN_TYPES.FILES:
+        case COLUMN_TYPES.TAGS:
+            return "stringArray";
+        case COLUMN_TYPES.TIMELINE:
+            return "object";
+        case COLUMN_TYPES.NUMBER:
+        case COLUMN_TYPES.HOURS:
+        case COLUMN_TYPES.CURRENCY:
+            return "number";
+        case COLUMN_TYPES.LINKED_COLUMN:
+        case COLUMN_TYPES.REF_LINED_COLUMN:
+            return "objectArray";
+        default:
+            return "string";
+    }
+};
+export const getDateGroupKey = (dateStr) => {
+    if (!dateStr)
+        return null;
+    const current = dayjs();
+    const day = dayjs(dateStr);
+    if (day.isBefore(current, "date")) {
+        return DATE_GROUPS.OVERDUE;
+    }
+    if (current.isSame(day, "date")) {
+        return DATE_GROUPS.TODAY;
+    }
+    const tomorrow = current.add(1, "day");
+    if (tomorrow.isSame(day, "date")) {
+        return DATE_GROUPS.TOMORROW;
+    }
+    const endDayOfThisWeek = current.set("day", 6);
+    if (day.isBefore(endDayOfThisWeek, "date") ||
+        day.isSame(endDayOfThisWeek, "date")) {
+        return DATE_GROUPS.THIS_WEEK;
+    }
+    const endDayOfNextWeek = endDayOfThisWeek.add(7, "day");
+    if (day.isAfter(endDayOfThisWeek, "date") &&
+        (day.isBefore(endDayOfNextWeek, "date") ||
+            day.isSame(endDayOfNextWeek, "date"))) {
+        return DATE_GROUPS.THIS_WEEK;
+    }
+    const endDayOfThisMonth = current.set("date", current.daysInMonth());
+    if (day.isBefore(endDayOfThisMonth, "date") ||
+        day.isSame(endDayOfThisMonth, "date")) {
+        return DATE_GROUPS.THIS_MONTH;
+    }
+    return DATE_GROUPS.FUTURE;
+};
+export const getValidConditions = (filter, headers) => {
+    if (!filter.criteria?.length || !headers?.length) {
+        return [];
+    }
+    // for dropdown, if set the option is in filter condition, and user delete the option. should ignore it or make the option can't be deleted
+    return filter.criteria.filter((c) => {
+        const validHeader = headers.find((h) => h.columnId === c.columnId);
+        if (!validHeader)
+            return false;
+        const validOperate = COLUMN_OP_TYPES[validHeader.type].includes(c.op);
+        if (!validOperate)
+            return false;
+        const isDropdown = [
+            COLUMN_TYPES.DROPDOWN,
+            COLUMN_TYPES.STATUS,
+            COLUMN_TYPES.PRIORITY,
+        ].includes(validHeader.type);
+        switch (c.op) {
+            case OP_TYPES.IS:
+            case OP_TYPES.IS_NOT:
+                return (c.blank ||
+                    (!!c.value?.filter((v) => !!v || v === 0)?.length &&
+                        (!isDropdown ||
+                            c.value.some((v) => validHeader.dropdowns?.find((d) => d.key === v)))));
+            case OP_TYPES.EMPTY:
+            case OP_TYPES.NOT_EMPTY:
+                return true;
+            case OP_TYPES.CONTAINS:
+            case OP_TYPES.NOT_CONTAINS:
+                return !!c.value?.length;
+            case OP_TYPES.EQUAL:
+            case OP_TYPES.NOT_EQUAL:
+            case OP_TYPES.GREATER:
+            case OP_TYPES.GREATER_EQUAL:
+            case OP_TYPES.LESS:
+            case OP_TYPES.LESS_EQUAL:
+                return !!c.value?.length;
+            default:
+                return false;
+        }
+    });
+};
+const isInConditionValues = (itemVal, valueType, condition) => {
+    switch (valueType) {
+        case "number":
+        case "string":
+            return ((condition.blank && !itemVal) ||
+                !!condition.value.find((val) => val === itemVal));
+        case "stringArray":
+            return ((condition.blank && !itemVal?.length) ||
+                condition.value.some((val) => Array.isArray(itemVal) && itemVal?.includes(val)));
+        case "object":
+            return ((condition.blank && !itemVal) ||
+                !!condition.value.find((val) => isEqual(val, itemVal)));
+        case "objectArray":
+            return ((condition.blank && !itemVal?.length) ||
+                condition.value.some((val) => Array.isArray(itemVal) &&
+                    itemVal.find((existVal) => isEqual(val, existVal))));
+        default:
+            break;
+    }
+    return false;
+};
+const isDateInConditionValues = (itemVal, condition) => {
+    if (condition.blank && !itemVal)
+        return true;
+    const groupKey = getDateGroupKey(itemVal);
+    if (!groupKey)
+        return !!condition.blank;
+    return !!condition.value?.find((dateGroup) => dateGroup === groupKey);
+};
+const isEmpty = (itemVal, valueType) => {
+    switch (valueType) {
+        case "number":
+        case "string":
+            return !itemVal;
+        case "stringArray":
+            return !itemVal?.length;
+        case "object":
+            return !itemVal || !Object.keys(itemVal).length;
+        case "objectArray":
+            return !itemVal?.length;
+        default:
+            break;
+    }
+    return true;
+};
+const isContains = (itemVal, valueType, condition) => {
+    const checkVal = condition.value?.length
+        ? condition.value[0]
+        : "";
+    switch (valueType) {
+        case "number":
+            return itemVal || itemVal === 0
+                ? itemVal.toString().includes(checkVal)
+                : false;
+        case "string":
+            return !!itemVal && itemVal.includes(checkVal);
+        case "stringArray":
+            return itemVal?.length
+                ? itemVal.some((val) => val.includes(checkVal))
+                : false;
+        default:
+            break;
+    }
+    return false;
+};
+const isEquals = (itemVal, valueType, condition) => {
+    const checkVal = condition.value?.length ? condition.value[0] : "";
+    switch (valueType) {
+        case "number":
+            return typeof checkVal === "number"
+                ? checkVal === itemVal
+                : parseInt(checkVal, 10) === itemVal;
+        case "string":
+            return !!itemVal && checkVal === itemVal;
+        case "object":
+            return isEqual(itemVal, checkVal);
+        default:
+            break;
+    }
+    return false;
+};
+const isGreater = (itemVal, condition) => {
+    const checkVal = condition.value?.length ? condition.value[0] : "";
+    if (typeof checkVal === "number") {
+        return itemVal > checkVal;
+    }
+    else {
+        const parseVal = parseInt(checkVal, 10);
+        return parseVal ? itemVal > parseVal : false;
+    }
+};
+const isGreaterEqual = (itemVal, condition) => {
+    const checkVal = condition.value?.length ? condition.value[0] : "";
+    if (typeof checkVal === "number") {
+        return itemVal >= checkVal;
+    }
+    else {
+        const parseVal = parseInt(checkVal, 10);
+        return parseVal ? itemVal >= parseVal : false;
+    }
+};
+const isLess = (itemVal, condition) => {
+    const checkVal = condition.value?.length ? condition.value[0] : "";
+    if (typeof checkVal === "number") {
+        return itemVal < checkVal;
+    }
+    else {
+        const parseVal = parseInt(checkVal, 10);
+        return parseVal ? itemVal < parseVal : false;
+    }
+};
+const isLessEqual = (itemVal, condition) => {
+    const checkVal = condition.value?.length ? condition.value[0] : "";
+    if (typeof checkVal === "number") {
+        return itemVal <= checkVal;
+    }
+    else {
+        const parseVal = parseInt(checkVal, 10);
+        return parseVal ? itemVal <= parseVal : false;
+    }
+};
+export const filterItemsByConditions = (groups, filter, headers) => {
+    if (!headers?.length)
+        return groups;
+    const validConditions = getValidConditions(filter, headers);
+    if (!validConditions?.length) {
+        return groups;
+    }
+    groups.forEach((g) => {
+        g.items = g.items?.filter((item) => {
+            let match = false;
+            for (const condition of validConditions) {
+                const header = headers?.find((h) => h.columnId === condition.columnId);
+                const valueType = getColumnValueType(header?.type ?? "");
+                const itemVal = item.data?.[condition.columnId]?.value;
+                const isDate = header?.type === COLUMN_TYPES.DATE;
+                switch (condition.op) {
+                    case OP_TYPES.IS:
+                        match = isDate
+                            ? isDateInConditionValues(itemVal, condition)
+                            : isInConditionValues(itemVal, valueType, condition);
+                        break;
+                    case OP_TYPES.IS_NOT:
+                        match = isDate
+                            ? !isDateInConditionValues(itemVal, condition)
+                            : !isInConditionValues(itemVal, valueType, condition);
+                        break;
+                    case OP_TYPES.EMPTY:
+                        match = isEmpty(itemVal, valueType);
+                        break;
+                    case OP_TYPES.NOT_EMPTY:
+                        match = !isEmpty(itemVal, valueType);
+                        break;
+                    case OP_TYPES.CONTAINS:
+                        match = isContains(itemVal, valueType, condition);
+                        break;
+                    case OP_TYPES.NOT_CONTAINS:
+                        match = !isContains(itemVal, valueType, condition);
+                        break;
+                    case OP_TYPES.EQUAL:
+                        match = isEquals(itemVal, valueType, condition);
+                        break;
+                    case OP_TYPES.NOT_EQUAL:
+                        match = !isEquals(itemVal, valueType, condition);
+                        break;
+                    case OP_TYPES.GREATER:
+                        match =
+                            typeof itemVal === "number"
+                                ? isGreater(itemVal, condition)
+                                : false;
+                        break;
+                    case OP_TYPES.GREATER_EQUAL:
+                        match =
+                            typeof itemVal === "number"
+                                ? isGreaterEqual(itemVal, condition)
+                                : false;
+                        break;
+                    case OP_TYPES.LESS_EQUAL:
+                        match =
+                            typeof itemVal === "number"
+                                ? isLessEqual(itemVal, condition)
+                                : false;
+                        break;
+                    case OP_TYPES.LESS:
+                        match =
+                            typeof itemVal === "number" ? isLess(itemVal, condition) : false;
+                        break;
+                    default:
+                        break;
+                }
+                if (!match)
+                    return false;
+            }
+            return match;
+        });
+    });
+    return groups;
+};
+export const filterBoardTree = (board, filter) => {
+    if (!board.groups?.length || !board.headers?.length)
+        return board;
+    return {
+        ...board,
+        groups: filterItemsByConditions(board.groups, filter, board.headers),
+    };
+};

package/dist/shared/types.d.ts

@@ -0,0 +1,96 @@
+export interface IBaseUser {
+    userId: string;
+    username: string;
+    email: string;
+    firstname: string;
+    lastname: string;
+}
+export interface ILinkedSource {
+    boardId: string;
+    boardName?: string;
+    columnId: string;
+    deleted?: number;
+    type: string;
+    name: string;
+    dropdowns?: {
+        key: string;
+        value: string;
+    }[];
+    setting?: IColumnSetting;
+}
+export interface IBaseItem {
+    itemId: string;
+    groupId?: string;
+    boardId?: string;
+    parentId?: string;
+    data?: Record<string, any>;
+    subs?: IBaseItem[];
+    index?: number;
+    deleted?: boolean;
+}
+export interface IColumnSetting {
+    currency?: string;
+}
+export interface IBaseCustomColumn {
+    columnId: string;
+    type: string;
+    name: string;
+    description?: string;
+    dropdowns?: {
+        key: string;
+        value: string;
+    }[];
+    linkedGroup?: string;
+    linked?: ILinkedSource;
+    index?: number;
+    deleted?: boolean;
+}
+export interface IBaseGroup {
+    groupId: string;
+    name: string;
+    description?: string;
+    items?: IBaseItem[];
+    deleted?: boolean;
+}
+export interface IBaseBoard {
+    name: string;
+    boardId: string;
+    type?: "board";
+    folderId?: string;
+    policyId?: string;
+    shareType?: number;
+    terminology?: string;
+    activeStatus?: number;
+    orgId?: string;
+    description?: string;
+    workspaceId?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface IPureBoard extends IBaseBoard {
+    headers?: IBaseCustomColumn[];
+    groups?: IBaseGroup[];
+    people?: IBaseUser[];
+}
+export interface IFilterCondition {
+    conditionId?: string;
+    columnId: string;
+    op: string;
+    value: string[] | number[];
+    blank?: boolean;
+}
+export interface IFilter {
+    andOr: "and" | "or";
+    criteria?: IFilterCondition[];
+}
+export interface IDynamicView {
+    filter?: IFilter;
+    viewId?: string;
+    displayColumns?: string[];
+    editScope: "all" | "own" | "notAllow";
+    allowNewItem?: boolean;
+    allowComment?: boolean;
+    step: "itemsSetting" | "customizeView" | "itemDetail" | "customizeForm" | "shareSetting";
+}

package/dist/shared/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./validator";

package/dist/utils/index.js

@@ -0,0 +1 @@
+export * from "./validator";

package/dist/utils/validator.d.ts

@@ -0,0 +1,3 @@
+export declare const isValidEmail: (email: string) => Promise<boolean>;
+export declare const isValidUrl: (url: string) => Promise<boolean>;
+export declare const isValidPhone: (phone: string) => Promise<boolean>;

package/dist/utils/validator.js

@@ -0,0 +1,36 @@
+import Schema from "async-validator";
+const descriptor = {
+    email: {
+        type: "email",
+        // @ts-ignore
+        validator: Schema.validators.email,
+    },
+    url: {
+        type: "url",
+        // @ts-ignore
+        validator: Schema.validators.url,
+    },
+    phone: {
+        type: "string", //+1 (408) 888-8888
+        pattern: /^(\+?1)?\(?[2-9]\d{2}\)?\s?\d{3}-?\d{4}$/,
+    },
+};
+const validator = new Schema(descriptor);
+export const isValidEmail = async (email) => {
+    await validator.validate({ email }).catch(err => {
+        throw err;
+    });
+    return true;
+};
+export const isValidUrl = async (url) => {
+    await validator.validate({ url }).catch(err => {
+        throw err;
+    });
+    return true;
+};
+export const isValidPhone = async (phone) => {
+    await validator.validate({ phone }).catch(err => {
+        throw err;
+    });
+    return true;
+};

package/package.json

@@ -1,26 +1,14 @@
 {
   "name": "@followupus/common",
-  "version": "0.0.2",
+  "version": "0.2.0",
   "description": "followup common utils npm package with TypeScript and VSCode",
+  "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],
   "type": "module",
-  "scripts": {
-    "dev": "tsc --watch",
-    "build": "tsc --project tsconfig.build.json",
-    "clean": "rm -rf ./dist",
-    "lint:staged": "lint-staged",
-    "format": "prettier --write \"**/*.{ts,tsx}\"",
-    "changeset": "changeset",
-    "version": "changeset version",
-    "release": "pnpm build && changeset publish --access public --registry=https://registry.npmjs.com/",
-    "lint": "eslint ./src/ --fix",
-    "test": "tsc && node --test build/test/**/*.spec.js",
-    "typecheck": "tsc --noEmit"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/followup/common.git"
@@ -51,6 +39,7 @@
     "@changesets/cli": "^2.27.1",
     "@commitlint/cli": "^19.1.0",
     "@commitlint/config-conventional": "^19.1.0",
+    "@types/lodash": "^4.17.0",
     "@types/node": "^20.11.26",
     "@typescript-eslint/eslint-plugin": "^7.2.0",
     "@typescript-eslint/parser": "^7.2.0",
@@ -74,5 +63,23 @@
   "simple-git-hooks": {
     "pre-commit": "pnpm lint-staged",
     "commit-msg": "pnpm commitlint -e \"$@\""
+  },
+  "dependencies": {
+    "async-validator": "^4.2.5",
+    "dayjs": "^1.11.10",
+    "lodash": "^4.17.21"
+  },
+  "scripts": {
+    "dev": "tsc --watch",
+    "build": "tsc --project tsconfig.build.json",
+    "clean": "rm -rf ./dist",
+    "lint:staged": "lint-staged",
+    "format": "prettier --write \"**/*.{ts,tsx}\"",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "pnpm build && changeset publish --access public --registry=https://registry.npmjs.com/",
+    "lint": "eslint ./src/ --fix",
+    "test": "tsc && node --test build/test/**/*.spec.js",
+    "typecheck": "tsc --noEmit"
   }
-}
+}