@sigmaott/base-library-next 2.2.6 → 2.2.8

package/src/utils/common.ts

@@ -1,175 +1,175 @@
-import { objectMap } from '@antfu/utils'
-
-export function emptyStr2Undefined(obj: Record<string, any>): Record<string, any> {
-  return objectMap(obj, (k, v) => !v ? undefined : [k, v])
-}
-
-/**
- * Generate rules for validation form that contain fields are sent to api
- * @param {Object} laws
- */
-export function genApiValidationRules(laws) {
-  const required = laws?.required || []
-  const props = laws?.properties || {}
-  const rules = {}
-
-  function generateRequiredRule(desc) {
-    return {
-      required: required.includes(desc.field),
-      message: 'Shouldn\'t be empty',
-      trigger: ['change', 'blur'],
-    }
-  }
-
-  function rulesForNumber(rule) {
-    const rules = []
-
-    const required = generateRequiredRule(rule)
-    rules.push(required)
-
-    function isNumber(value) {
-      return typeof value === 'number'
-    }
-
-    function isValidMin(value, min) {
-      return value >= min
-    }
-
-    function isValidMax(value, max) {
-      return value <= max
-    }
-
-    function validate(currentRule, value, callback) {
-      if (!isNumber(value)) {
-        if (value)
-          callback(new Error('Should be a number'))
-
-        else
-          callback()
-
-        return
-      }
-
-      if ((rule.minimum || rule.minimum === 0) && !isValidMin(value, rule.minimum)) {
-        callback(new Error(`Should be greater than or equal ${rule.minimum}`))
-        return
-      }
-      if (rule.maximum && !isValidMax(value, rule.maximum)) {
-        callback(new Error(`Should be less than or equal ${rule.maximum}`))
-        return
-      }
-      if (rule.enum && Array.isArray(rule.enum) && !rule.enum.includes(value)) {
-        callback(new Error(`Must be one of values: ${rule.num.join(', ')}`))
-        return
-      }
-      callback()
-    }
-
-    const tmpRule = {
-      validator: validate,
-      trigger: ['blur', 'change'],
-    }
-    rules.push(tmpRule)
-
-    return rules
-  }
-
-  function rulesForString(rule) {
-    const rules = []
-
-    const required = generateRequiredRule(rule)
-    rules.push(required)
-
-    function validate(currentRule, value, callback) {
-      if (rule.length && !value.length === rule.length)
-        return callback(new Error(`${rule.label} must be ${rule.length} characters`))
-
-      if (rule.minLength && value.length < rule.minLength)
-        return callback(new Error(`Min ${rule.minLength} character(s)`))
-
-      if (rule.maxLength && value.length > rule.maxLength)
-        return callback(new Error(`Max ${rule.maxLength} character(s)`))
-
-      if (rule.pattern) {
-        const pattern = rule.pattern
-        const patternStr = pattern.slice(1, -1)
-        const regex = new RegExp(patternStr)
-        if (!regex.test(value))
-          return callback(new Error(`Invalid format ${rule.pattern}`))
-      }
-      if (rule.enum && Array.isArray(rule.enum)) {
-        if (value && !rule.enum.includes(value))
-          return callback(new Error(`Must be one of values: ${rule.enum.join(', ')}`))
-      }
-      return callback()
-    }
-
-    rules.push({
-      validator: validate,
-      trigger: ['change', 'blur'],
-    })
-
-    return rules
-  }
-
-  function rulesForBoolean(rule) {
-    const rules = []
-
-    const required = generateRequiredRule(rule)
-    rules.push(required)
-
-    function isBoolean(value) {
-      return typeof value === 'boolean'
-    }
-
-    function validate(currentRule, value, callback) {
-      if (!isBoolean(value))
-        callback(new Error('Should be a boolean value'))
-
-      else
-        callback()
-    }
-
-    const tmpRule = {
-      validator: validate,
-      trigger: ['change', 'blur'],
-    }
-    rules.push(tmpRule)
-
-    return rules
-  }
-
-  for (const field in props) {
-    const desc = props[field]
-    if (desc.$ref) {
-      // Check if rule is a reference
-      continue
-    }
-    else {
-      desc.field = field
-      if (desc.title)
-        desc.title = field
-
-      const fieldType = desc.type
-
-      switch (fieldType) {
-        case 'string': {
-          const rule = rulesForString(desc)
-          rules[field] = rule
-          break
-        }
-        case 'number': {
-          const rule = rulesForNumber(desc)
-          rules[field] = rule
-          break
-        }
-        case 'boolean': {
-          const rule = rulesForBoolean(desc)
-          rules[field] = rule
-          break
-        }
-      }
-    }
-  }
-  return rules
-}
+import { objectMap } from '@antfu/utils'
+
+export function emptyStr2Undefined(obj: Record<string, any>): Record<string, any> {
+  return objectMap(obj, (k, v) => !v ? undefined : [k, v])
+}
+
+/**
+ * Generate rules for validation form that contain fields are sent to api
+ * @param {Object} laws
+ */
+export function genApiValidationRules(laws) {
+  const required = laws?.required || []
+  const props = laws?.properties || {}
+  const rules = {}
+
+  function generateRequiredRule(desc) {
+    return {
+      required: required.includes(desc.field),
+      message: 'Shouldn\'t be empty',
+      trigger: ['change', 'blur'],
+    }
+  }
+
+  function rulesForNumber(rule) {
+    const rules = []
+
+    const required = generateRequiredRule(rule)
+    rules.push(required)
+
+    function isNumber(value) {
+      return typeof value === 'number'
+    }
+
+    function isValidMin(value, min) {
+      return value >= min
+    }
+
+    function isValidMax(value, max) {
+      return value <= max
+    }
+
+    function validate(currentRule, value, callback) {
+      if (!isNumber(value)) {
+        if (value)
+          callback(new Error('Should be a number'))
+
+        else
+          callback()
+
+        return
+      }
+
+      if ((rule.minimum || rule.minimum === 0) && !isValidMin(value, rule.minimum)) {
+        callback(new Error(`Should be greater than or equal ${rule.minimum}`))
+        return
+      }
+      if (rule.maximum && !isValidMax(value, rule.maximum)) {
+        callback(new Error(`Should be less than or equal ${rule.maximum}`))
+        return
+      }
+      if (rule.enum && Array.isArray(rule.enum) && !rule.enum.includes(value)) {
+        callback(new Error(`Must be one of values: ${rule.num.join(', ')}`))
+        return
+      }
+      callback()
+    }
+
+    const tmpRule = {
+      validator: validate,
+      trigger: ['blur', 'change'],
+    }
+    rules.push(tmpRule)
+
+    return rules
+  }
+
+  function rulesForString(rule) {
+    const rules = []
+
+    const required = generateRequiredRule(rule)
+    rules.push(required)
+
+    function validate(currentRule, value, callback) {
+      if (rule.length && !value.length === rule.length)
+        return callback(new Error(`${rule.label} must be ${rule.length} characters`))
+
+      if (rule.minLength && value.length < rule.minLength)
+        return callback(new Error(`Min ${rule.minLength} character(s)`))
+
+      if (rule.maxLength && value.length > rule.maxLength)
+        return callback(new Error(`Max ${rule.maxLength} character(s)`))
+
+      if (rule.pattern) {
+        const pattern = rule.pattern
+        const patternStr = pattern.slice(1, -1)
+        const regex = new RegExp(patternStr)
+        if (!regex.test(value))
+          return callback(new Error(`Invalid format ${rule.pattern}`))
+      }
+      if (rule.enum && Array.isArray(rule.enum)) {
+        if (value && !rule.enum.includes(value))
+          return callback(new Error(`Must be one of values: ${rule.enum.join(', ')}`))
+      }
+      return callback()
+    }
+
+    rules.push({
+      validator: validate,
+      trigger: ['change', 'blur'],
+    })
+
+    return rules
+  }
+
+  function rulesForBoolean(rule) {
+    const rules = []
+
+    const required = generateRequiredRule(rule)
+    rules.push(required)
+
+    function isBoolean(value) {
+      return typeof value === 'boolean'
+    }
+
+    function validate(currentRule, value, callback) {
+      if (!isBoolean(value))
+        callback(new Error('Should be a boolean value'))
+
+      else
+        callback()
+    }
+
+    const tmpRule = {
+      validator: validate,
+      trigger: ['change', 'blur'],
+    }
+    rules.push(tmpRule)
+
+    return rules
+  }
+
+  for (const field in props) {
+    const desc = props[field]
+    if (desc.$ref) {
+      // Check if rule is a reference
+      continue
+    }
+    else {
+      desc.field = field
+      if (desc.title)
+        desc.title = field
+
+      const fieldType = desc.type
+
+      switch (fieldType) {
+        case 'string': {
+          const rule = rulesForString(desc)
+          rules[field] = rule
+          break
+        }
+        case 'number': {
+          const rule = rulesForNumber(desc)
+          rules[field] = rule
+          break
+        }
+        case 'boolean': {
+          const rule = rulesForBoolean(desc)
+          rules[field] = rule
+          break
+        }
+      }
+    }
+  }
+  return rules
+}

package/src/utils/config.ts

@@ -1,19 +1,19 @@
-export const VIDEO_CODECS = {
-  H264: 'h264',
-  HEVC: 'hevc',
-  COPY: 'copy',
-}
-
-export const AUDIO_CODECS = {
-  AAC: 'aac',
-  AC3: 'ac3',
-  EAC3: 'eac3',
-  MP2: 'mp2',
-  COPY: 'copy',
-}
-
-export const DATA_CODECS = {
-  SCTE35: 'scte35',
-  ID3: 'id3',
-  COPY: 'copy',
-}
+export const VIDEO_CODECS = {
+  H264: 'h264',
+  HEVC: 'hevc',
+  COPY: 'copy',
+}
+
+export const AUDIO_CODECS = {
+  AAC: 'aac',
+  AC3: 'ac3',
+  EAC3: 'eac3',
+  MP2: 'mp2',
+  COPY: 'copy',
+}
+
+export const DATA_CODECS = {
+  SCTE35: 'scte35',
+  ID3: 'id3',
+  COPY: 'copy',
+}