@inriver/inri 1.0.0

package/src/utils/colorUtils.ts

@@ -0,0 +1,73 @@
+interface RelatedColors {
+  onColor: string,
+  onAltColor?: string,
+  effectColor: string,
+}
+
+export const baseColors = ['primary', 'secondary', 'accent', 'surface']
+export const blackAndWhiteColors = ['black', 'white']
+export const spotColors = ['blue', 'purple', 'red', 'orange', 'yellow', 'green']
+export const lightColors = ['blue-light', 'purple-light', 'red-light', 'orange-light', 'yellow-light', 'green-light']
+export const greyColors = ['grey-darkest', 'grey-darker', 'grey-dark', 'grey', 'grey-light', 'grey-lighter']
+
+export const colors = {
+  baseColors,
+  blackAndWhiteColors,
+  spotColors,
+  lightColors,
+  greyColors,
+}
+
+export const getRelatedColors = (color): RelatedColors | null => {
+  if (color === 'primary') {
+    return {
+      onColor: 'on-primary',
+      onAltColor: 'on-primary-alt',
+      effectColor: 'primary-effect',
+    } as RelatedColors
+  } else if (color === 'secondary') {
+    return {
+      onColor: 'on-secondary',
+      onAltColor: 'on-secondary-alt',
+      effectColor: 'secondary-effect',
+    } as RelatedColors
+  } else if (color === 'accent') {
+    return {
+      onColor: 'on-accent',
+      onAltColor: 'on-accent-alt',
+      effectColor: 'accent-effect',
+    } as RelatedColors
+  } else if (color === 'surface') {
+    return {
+      onColor: 'on-surface',
+      effectColor: 'surface-effect',
+    } as RelatedColors
+  } else if (spotColors.includes(color)) {
+    return {
+      onColor: 'grey-darkest',
+      effectColor: `${color}-light`,
+    } as RelatedColors
+  } else if (color === 'black') {
+    return {
+      onColor: 'white',
+      effectColor: 'grey-darker',
+    } as RelatedColors
+  } else if (color === 'white') {
+    return {
+      onColor: 'grey-darkest',
+      effectColor: 'grey-lighter',
+    } as RelatedColors
+  } else if (color === 'grey-lighter') {
+    return {
+      onColor: 'grey-darkest',
+      effectColor: 'grey-light',
+    } as RelatedColors
+  } else if (color.endsWith('-light')) {
+    return {
+      onColor: 'grey-darkest',
+      effectColor: color.replace('-light', ''),
+    } as RelatedColors
+  }
+
+  return null
+}

package/src/utils/errorUtils.ts

@@ -0,0 +1,37 @@
+import { i18n } from '../plugins/i18n'
+
+/**
+ * Try to get an error message returned from the server. It could be a i18n key or just a normal error message.
+ * If a namespace is given then try to find the translation here. Fallback to the shared generic errors.
+ * @param [error] - Exception
+ * @param {string?} [namespace] - optional namespace where you want to find your i18n translation ('folders' will try to get from 'folders.foo_error')
+ */
+export const getErrorMessage = (error: any, namespace: string | undefined = undefined) : string => {
+  const t = i18n.global.t
+  const te = i18n.global.te
+
+  const errorDescription = error.response?.data?.errorDescription ||
+    error.response?.data?.message ||
+    error.response?.data ||
+    error.request?.statusText ||
+    error?.message ||
+    error.toString()
+
+  if (!errorDescription) {
+    return t('inri.error.undefined_error')
+  }
+
+  let translatedError
+
+  // First try to get the translation from the given namespace
+  if (namespace) {
+    translatedError = te(`${namespace}.${errorDescription}`) ? t(`${namespace}.${errorDescription}`) : undefined
+  }
+
+  // If not found in namespace or namespace is not defined try to get it from the global errors
+  if (!translatedError) {
+    translatedError = te(`inri.error.${errorDescription}`) ? t(`inri.error.${errorDescription}`) : undefined
+  }
+
+  return translatedError || errorDescription || t('inri.error.undefined_error')
+}

package/src/utils/fileUtils.ts

@@ -0,0 +1,57 @@
+export const invalidFileChars = ['#', '%', '&', '{', '}', '\\', '<', '>', '*', '?', '/', '$', '!', "'", '"', ':', '@', '+', '`', '|', '=']
+
+export const maxFileLength = 30
+
+export const forbiddenFilePrefixAndSuffix = ['.', '-', '_']
+
+export const invalidFileExtensions = ['.exe']
+
+export function getFileExtension (fileName = '') {
+  if (fileName.includes('.')) {
+    return fileName.substring(fileName.lastIndexOf('.') + 1, fileName.length)
+  }
+
+  return ''
+}
+
+/**
+ * Converts bytes to an appropriate size unit, outputted in a readable format
+ * @param {number} bytes - Value to be converted and formatted
+ * @param {number} [decimals] - Specifies how many decimals the result should contain, defaults to 0 (no decimals)
+ * @returns {string} The converted value in a readable format
+ */
+export function bytesToReadableSize (bytes: number, decimals = 0) {
+  const sizes = ['Bytes', 'KB', 'MB', 'GB']
+
+  if (bytes === 0) {
+    return '0 Bytes'
+  }
+
+  const dm = decimals < 0 ? 0 : decimals
+  const i = Math.floor(Math.log(bytes) / Math.log(1024))
+
+  return (bytes / Math.pow(1024, i)).toFixed(dm) + ' ' + sizes[i]
+}
+
+/**
+ * Converts a file to a Base64 encoded string
+ * @param { File | any } file - File object
+ * @returns A promise that returns a Base64 encoded string when resolved
+ */
+export function convertFileToBase64 (file) {
+  return new Promise<string>((resolve, reject) => {
+    const reader = new FileReader()
+    reader.onload = () => {
+      const result = reader.result as string
+      resolve(result.split(',').pop() as string)
+    }
+    reader.onerror = reject
+    reader.readAsDataURL(file)
+  })
+}
+
+export const textFileExtensionWhitelist = ['txt', 'md', 'xml']
+
+export function isTextFile (filename: string) {
+  return textFileExtensionWhitelist.includes(getFileExtension(filename).toLowerCase())
+}

package/src/utils/helpers.ts

@@ -0,0 +1,6 @@
+// Helpful function if you want to generate different size images from eg. faker.js
+export function getRandomInt (min: number, max: number) {
+  min = Math.ceil(min)
+  max = Math.floor(max)
+  return Math.floor(Math.random() * (max - min) + min)
+}

package/src/utils/routeUtils.ts

@@ -0,0 +1,23 @@
+import { RouteLocationNormalized, RouteLocationNormalizedLoaded, RouteRecordNormalized } from 'vue-router'
+
+function isRouteLocation (arg): arg is RouteLocationNormalized | RouteLocationNormalizedLoaded {
+  return arg && arg.params
+}
+
+export const getRouteTitle = (
+  route: RouteLocationNormalized | RouteLocationNormalizedLoaded | RouteRecordNormalized | string,
+  to?: RouteLocationNormalized | RouteLocationNormalizedLoaded | RouteRecordNormalized | string,
+) => {
+  let title = typeof route !== 'string' ? route.meta.title as string : route
+
+  // If "to" is not passed as a parameter then use the current route as "to"
+  to = to || route
+
+  if (isRouteLocation(to)) {
+    for (const [key, value] of Object.entries(to.params)) {
+      title = title.replace(`:${key}`, value as string)
+    }
+  }
+
+  return title
+}

package/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "noImplicitAny": false,
+    "target": "esnext",
+    "module": "esnext",
+    "strict": true,
+    "jsx": "preserve",
+    "importHelpers": true,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "types": [
+      "webpack-env"
+    ],
+    "lib": [
+      "esnext",
+      "dom",
+      "dom.iterable",
+      "scripthost"
+    ]
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    "src/**/*.vue",
+    "tests/**/*.ts",
+    "tests/**/*.tsx",
+    "componentProperties.d.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}