@andre1502/react-utilities 0.9.0

package/package.json

@@ -0,0 +1,139 @@
+{
+  "name": "@andre1502/react-utilities",
+  "version": "0.9.0",
+  "description": "module to combine common functions",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/andre1502/react-utilities"
+  },
+  "license": "MIT",
+  "author": "andre1502",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    },
+    "./fmt": {
+      "types": "./dist/index-fmt.d.ts",
+      "require": "./dist/index-fmt.cjs",
+      "import": "./dist/index-fmt.mjs"
+    },
+    "./react-native": {
+      "types": "./dist/index-rn.d.ts",
+      "require": "./dist/index-rn.cjs",
+      "import": "./dist/index-rn.mjs"
+    },
+    "./cli": {
+      "types": "./dist/index-cli.d.ts",
+      "require": "./dist/index-cli.cjs",
+      "import": "./dist/index-cli.mjs"
+    },
+    "./format": {
+      "types": "./dist/format.d.ts",
+      "require": "./dist/format.cjs",
+      "import": "./dist/format.mjs"
+    },
+    "./sentry": {
+      "types": "./dist/sentry.d.ts",
+      "require": "./dist/sentry.cjs",
+      "import": "./dist/sentry.mjs"
+    },
+    "./sentry-rn": {
+      "types": "./dist/sentry-rn.d.ts",
+      "require": "./dist/sentry-rn.cjs",
+      "import": "./dist/sentry-rn.mjs"
+    },
+    "./sentry-cli": {
+      "types": "./dist/sentry-cli.d.ts",
+      "require": "./dist/sentry-cli.cjs",
+      "import": "./dist/sentry-cli.mjs"
+    },
+    "./config-cli": {
+      "types": "./dist/config-cli.d.ts",
+      "require": "./dist/config-cli.cjs",
+      "import": "./dist/config-cli.mjs"
+    }
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "react-native": "dist/index-rn.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "src",
+    "dist"
+  ],
+  "scripts": {
+    "prebuild": "rm -rf ./tsconfig.tsbuildinfo && rm -rf ./.rollup.cache && rm -rf ./dist",
+    "build": "yarn prebuild && yarn build:esm && yarn build:cjs && yarn build:bundles && yarn declarations",
+    "build:bundles": "cross-env BABEL_ENV=esmBundled node --max-old-space-size=8192 ./node_modules/rollup/dist/bin/rollup --config",
+    "build:cjs": "cross-env BABEL_ENV=cjs babel src --extensions '.ts' --out-dir 'dist' --source-maps",
+    "build:esm": "cross-env BABEL_ENV=esmUnbundled babel src --extensions '.ts' --out-dir 'dist' --source-maps",
+    "declarations": "tsc -p tsconfig.json",
+    "format": "prettier --write --parser typescript '**/*.{ts,tsx}'",
+    "lint": "eslint . --ext .ts,.tsx --ignore-path .gitignore --fix",
+    "prepublishOnly": "yarn build",
+    "test": "echo \"Warn: no test specified, ignore it\" && exit 0"
+  },
+  "dependencies": {
+    "@formatjs/intl-datetimeformat": "^6.12.5",
+    "@formatjs/intl-displaynames": "^6.6.8",
+    "@formatjs/intl-getcanonicallocales": "^2.3.0",
+    "@formatjs/intl-listformat": "^7.5.7",
+    "@formatjs/intl-locale": "^4.0.0",
+    "@formatjs/intl-numberformat": "^8.10.3",
+    "@formatjs/intl-pluralrules": "^5.2.14",
+    "@formatjs/intl-relativetimeformat": "^11.2.14",
+    "@sentry/react-native": "^5.26.0",
+    "@types/lodash": "^4.17.7",
+    "google-auth-library": "^9.11.0",
+    "googleapis": "^140.0.1",
+    "lodash": "^4.17.21",
+    "sitemap": "^8.0.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.24.8",
+    "@babel/core": "^7.24.9",
+    "@babel/preset-env": "^7.24.8",
+    "@babel/preset-react": "^7.24.7",
+    "@babel/preset-typescript": "^7.24.7",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@rollup/plugin-commonjs": "^26.0.1",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "@types/node": "^20.14.11",
+    "@types/react": "^18.3.3",
+    "@typescript-eslint/eslint-plugin": "^7.16.1",
+    "@typescript-eslint/parser": "^7.16.1",
+    "cross-env": "^7.0.3",
+    "eslint": "^9.7.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-react": "^7.34.4",
+    "eslint-plugin-react-hooks": "^4.6.2",
+    "eslint-plugin-storybook": "^0.8.0",
+    "prettier": "^3.3.3",
+    "prettier-plugin-organize-imports": "^4.0.0",
+    "prettier-plugin-packagejson": "^2.5.1",
+    "rollup": "^4.19.1",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "tslib": "^2.6.3",
+    "typescript": "^5.5.3",
+    "yarn-upgrade-all": "^0.7.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-dom": "*",
+    "react-native": "*",
+    "tslib": "*"
+  },
+  "optionalDependencies": {
+    "@rollup/rollup-linux-x64-gnu": "^4.13.2"
+  },
+  "packageManager": "yarn@4.3.1",
+  "publishConfig": {
+    "@andre1502:registry": "https://registry.npmjs.org/"
+  }
+}

package/src/Config/Config.ts

@@ -0,0 +1,258 @@
+import * as lodash from 'lodash';
+import { OutputMap } from '../interfaces/Config/OutputMap';
+import { OutputOptions } from '../interfaces/Config/OutputOptions';
+import { outputToFile } from './Output';
+
+/**
+ * Process config data
+ *
+ * @param {any[][]} rows
+ * @return {OutputMap}
+ */
+const processConfig = (rows: any[][]): OutputMap => {
+  let versionConfig: OutputMap = {};
+
+  let params = rows[0].map((key) => {
+    return key;
+  });
+
+  rows.forEach((row: string[], index: number) => {
+    if (index === 0) {
+      return;
+    }
+
+    versionConfig = processRow(row, params, versionConfig);
+  });
+
+  return versionConfig;
+};
+
+/**
+ * Process config item
+ *
+ * @param {string[]} data
+ * @param {string[]} params
+ * @param {OutputMap} versionConfig
+ * @return {OutputMap}
+ */
+const processRow = (
+  data: string[],
+  params: string[],
+  versionConfig: OutputMap,
+): OutputMap => {
+  const versionName = data[0];
+  versionConfig[versionName] = {};
+
+  params.forEach((paramsName, index) => {
+    if (index === 0 || data[index] === undefined || data[index] === '') {
+      return;
+    }
+
+    versionConfig[versionName][paramsName] = paramsTypeHandler(data[index]);
+  });
+
+  return versionConfig;
+};
+
+/**
+ * Check is JSON value
+ *
+ * @param {string} str
+ * @return {boolean}
+ */
+const isJsonString = (str: string): boolean => {
+  try {
+    JSON.parse(str);
+  } catch (e) {
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ * Handling config value type
+ *
+ * @param {string} params
+ * @return {any}
+ */
+const paramsTypeHandler = (params: string): any => {
+  const booleanText = ['TRUE', 'FALSE'];
+
+  if (booleanText.includes(params.toUpperCase())) {
+    return params === 'TRUE';
+  }
+
+  if (isJsonString(params)) {
+    return JSON.parse(params);
+  }
+
+  return params;
+};
+
+/**
+ * Export config data into js file
+ *
+ * @param {OutputMap} data
+ * @param {OutputOptions} options
+ * @return {void}
+ */
+const exportConfig = (data: OutputMap, options: OutputOptions): void => {
+  const config = {
+    params: data,
+  };
+
+  const content = `module.exports = ${JSON.stringify(config, null, 2)}`;
+
+  outputToFile(content, options);
+};
+
+/**
+ * Handling env map value
+ *
+ * @param {string} env
+ * @return {string}
+ */
+const envMap = (env: string): string => {
+  let result;
+
+  switch (env) {
+    case 'dev':
+    case 'develop':
+    case 'development':
+      result = 'dev';
+      break;
+    case 'stg':
+    case 'stag':
+    case 'staging':
+      result = 'staging';
+      break;
+    case 'prd':
+    case 'prod':
+    case 'production':
+      result = 'production';
+      break;
+    default:
+      throw new Error(`env ${env} not supported.`);
+  }
+
+  return result;
+};
+
+/**
+ * Mapping content to exportAs value
+ *
+ * @param {string} key
+ * @param {any} value
+ * @param {string} exportAs
+ * @return {string}
+ */
+const contentMap = (key: string, value: any, exportAs: string): string => {
+  let content = '';
+
+  switch (exportAs) {
+    case 'ts':
+      if (lodash.isNull(value)) {
+        content += `export const ${key}: string | null = ${value};\n`;
+      } else if (typeof value === 'boolean') {
+        content += `export const ${key}: boolean = ${value};\n`;
+      } else {
+        content += `export const ${key} = '${value}';\n`;
+      }
+      break;
+    case 'js':
+      content += `export const ${key} = "${value}";\n`;
+      break;
+    case 'env':
+      content += `${key} = "${value}"\n`;
+      break;
+    default:
+      throw new Error(`exportAs ${exportAs} not supported.`);
+  }
+
+  return content;
+};
+
+/**
+ * Transform config
+ *
+ * @param {OutputMap} data
+ * @param {string} env
+ * @param {string} configKeyPrefix
+ * @param {OutputOptions} options
+ * @return {void}
+ */
+const transformConfig = (
+  data: OutputMap,
+  env: string,
+  configKeyPrefix: string,
+  options: OutputOptions,
+): void => {
+  const envKey = configKeyPrefix ? `${configKeyPrefix}ENV` : 'ENV';
+
+  let content = contentMap(envKey, envMap(env), options.exportAs!);
+
+  Object.keys(data).forEach((key) => {
+    const newConfigKey = configKeyPrefix ? `${configKeyPrefix}${key}` : key;
+
+    if (key === 'BASE_PROJECT') {
+      const extensionFile = [
+        `.${data[key]}.js`,
+        `.${data[key]}.jsx`,
+        `.${data[key]}.ts`,
+        `.${data[key]}.tsx`,
+        `.${data[key]}.css`,
+        `.${data[key]}.json`,
+        `.${data[key]}.scss`,
+      ];
+
+      content += contentMap(
+        newConfigKey,
+        extensionFile.join(','),
+        options.exportAs!,
+      );
+
+      return;
+    }
+
+    if (key === 'SITEMAP') {
+      content += contentMap(
+        newConfigKey,
+        JSON.stringify(data[key]),
+        options.exportAs!,
+      );
+
+      return;
+    }
+
+    if (Array.isArray(data[key])) {
+      content += contentMap(
+        newConfigKey,
+        data[key].join(','),
+        options.exportAs!,
+      );
+
+      return;
+    }
+
+    if (typeof data[key] === 'object') {
+      if (data[key].hasOwnProperty(env)) {
+        content += contentMap(newConfigKey, data[key][env], options.exportAs!);
+      } else {
+        content += contentMap(
+          newConfigKey,
+          JSON.stringify(data[key]),
+          options.exportAs!,
+        );
+      }
+
+      return;
+    }
+
+    content += contentMap(newConfigKey, data[key], options.exportAs!);
+  });
+
+  outputToFile(content, options);
+};
+
+export { exportConfig, processConfig, transformConfig };

package/src/Config/GoogleAuth.ts

@@ -0,0 +1,54 @@
+import { existsSync } from 'fs';
+import { GoogleAuth } from 'google-auth-library';
+import { JSONClient } from 'google-auth-library/build/src/auth/googleauth';
+import { google } from 'googleapis';
+import * as path from 'path';
+import * as process from 'process';
+
+const SCOPES = ['https://www.googleapis.com/auth/spreadsheets.readonly'];
+const GOOGLE_APPLICATION_CREDENTIALS_PATH = path.join(
+  process.cwd(),
+  '/google_application_credentials.json',
+);
+
+/**
+ * Authenticate using google console service account.
+ * @return {GoogleAuth<JSONClient>}
+ */
+const authorizeServiceAccount = (): GoogleAuth<JSONClient> => {
+  const isExist = existsSync(GOOGLE_APPLICATION_CREDENTIALS_PATH);
+
+  const options: any = {
+    scopes: SCOPES,
+  };
+
+  if (isExist) {
+    options.keyFile = GOOGLE_APPLICATION_CREDENTIALS_PATH;
+  }
+
+  return new GoogleAuth(options);
+};
+
+/**
+ * @param {GoogleAuth<JSONClient>} auth The authenticated Google OAuth client.
+ * @param {string} spreadsheetId
+ * @param {string} spreadsheetTab
+ * @return {Promise<any[][] | null | undefined>}
+ */
+const fetchGoogleSheet = async (
+  auth: GoogleAuth<JSONClient>,
+  spreadsheetId: string,
+  spreadsheetTab: string,
+): Promise<any[][] | null | undefined> => {
+  const sheets = google.sheets({ version: 'v4', auth });
+
+  const res = await sheets.spreadsheets.values.get({
+    spreadsheetId: spreadsheetId,
+    range: spreadsheetTab,
+    majorDimension: 'COLUMNS',
+  });
+
+  return res.data.values;
+};
+
+export { authorizeServiceAccount, fetchGoogleSheet };

package/src/Config/Locales.ts

@@ -0,0 +1,72 @@
+import { OutputMap } from '../interfaces/Config/OutputMap';
+import { OutputOptions } from '../interfaces/Config/OutputOptions';
+import { StringMap } from '../interfaces/Config/StringMap';
+import { outputToFile } from './Output';
+
+/**
+ * Process locales data
+ *
+ * @param {any[][]} rows
+ * @return {OutputMap}
+ */
+const processLocales = (rows: any[][]): OutputMap => {
+  let keys = rows[0].map((key) => {
+    return key;
+  });
+
+  let data: OutputMap = {};
+
+  rows.forEach((lang: string[], index: number) => {
+    if (index === 0) {
+      return;
+    }
+
+    let langData: StringMap = {};
+
+    lang.forEach((data: string, dIndex: number) => {
+      if (dIndex === 0) {
+        return;
+      }
+
+      langData[keys[dIndex]] = data;
+    });
+
+    data[lang[0]] = langData;
+  });
+
+  return data;
+};
+
+/**
+ * Export locales data to file
+ *
+ * @param {OutputMap} data
+ * @param {OutputOptions} options
+ * @return {void}
+ */
+const exportLocales = (data: OutputMap, options: OutputOptions): void => {
+  Object.keys(data).forEach((key) => {
+    options.filename = `${key}.${options.exportAs!.toLowerCase()}`;
+
+    let content = '';
+
+    switch (options.exportAs) {
+      case 'ts':
+        content = 'export default ' + JSON.stringify(data[key], null, 2);
+        break;
+      case 'json':
+        content = JSON.stringify(data[key], null, 2);
+        break;
+      default:
+        throw new Error(`exportAs ${options.exportAs} not supported.`);
+    }
+
+    if (!content) {
+      throw new Error(`empty content, please check remote value.`);
+    }
+
+    outputToFile(content, options);
+  });
+};
+
+export { exportLocales, processLocales };

package/src/Config/Output.ts

@@ -0,0 +1,29 @@
+import { writeFile } from 'fs';
+import { OutputOptions } from '../interfaces/Config/OutputOptions';
+
+/**
+ * Write content into target file
+ *
+ * @param {string} content
+ * @param {OutputOptions} options
+ * @return {void}
+ */
+const outputToFile = (content: string, options: OutputOptions): void => {
+  let filename = options.filename;
+
+  if (options.isFilenameLowercase) {
+    filename = filename.toLowerCase();
+  }
+
+  const filePath = `${options.folder}/${filename}`;
+
+  writeFile(filePath, content, 'utf8', function (err) {
+    if (err) {
+      throw err;
+    }
+
+    console.log(filePath, content);
+  });
+};
+
+export { outputToFile };

package/src/Config/Sitemap.ts

@@ -0,0 +1,67 @@
+import { SitemapStream, streamToPromise } from 'sitemap';
+import { Readable } from 'stream';
+import { OutputOptions } from '../interfaces/Config/OutputOptions';
+import { SitemapMap } from '../interfaces/Config/SitemapMap';
+import { outputToFile } from './Output';
+
+/**
+ * Generate Sitemap Robots
+ *
+ * @param {string} hostname
+ * @param {OutputOptions} options
+ * @return {void}
+ */
+const generateRobots = (hostname: string, options: OutputOptions): void => {
+  let content = [
+    '# https://www.robotstxt.org/robotstxt.html',
+    `Sitemap: ${hostname}/${options.filename}`,
+    'User-agent: *',
+    'Disallow:',
+  ];
+
+  options.filename = 'robots.txt';
+
+  outputToFile(content.join('\r\n'), options);
+};
+
+/**
+ * Transform Sitemap
+ *
+ * @param {string} hostname
+ * @param {SitemapMap[]} urls
+ * @param {boolean} includeRobots
+ * @param {OutputOptions} options
+ * @return {Promise<void>}
+ */
+const transformSitemap = async (
+  hostname: string,
+  urls: SitemapMap[],
+  includeRobots: boolean,
+  options: OutputOptions,
+): Promise<void> => {
+  const stream = new SitemapStream({
+    hostname: hostname,
+    lastmodDateOnly: false,
+    xmlns: {
+      news: false,
+      xhtml: false,
+      image: false,
+      video: false,
+      custom: [
+        'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"',
+        'xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd"',
+      ],
+    },
+  });
+  const content = await streamToPromise(Readable.from(urls).pipe(stream)).then(
+    (data) => data.toString(),
+  );
+
+  outputToFile(content, options);
+
+  if (includeRobots) {
+    generateRobots(hostname, options);
+  }
+};
+
+export { transformSitemap };