@ditojs/admin 2.100.0 → 3.1.0

package/src/utils/schema/structure.js

@@ -0,0 +1,172 @@
+import { isObject, isString } from '@ditojs/utils'
+import { getTypeOptions, getSourceType } from './types.js'
+
+export function iterateSchemaComponents(schemas, callback) {
+  for (const schema of schemas) {
+    if (isSingleComponentView(schema)) {
+      const res = callback(schema.component, schema.name, 0)
+      if (res !== undefined) {
+        return res
+      }
+    } else if (isSchema(schema)) {
+      for (const [name, component] of Object.entries(schema.components || {})) {
+        const res = callback(component, name, 1)
+        if (res !== undefined) {
+          return res
+        }
+      }
+    }
+  }
+}
+
+export function iterateNestedSchemaComponents(schema, callback) {
+  return schema
+    ? iterateSchemaComponents([schema, ...getTabSchemas(schema)], callback)
+    : undefined
+}
+
+export function findNestedSchemaComponent(schema, callback) {
+  return (
+    iterateNestedSchemaComponents(
+      schema,
+      component => (callback(component) ? component : undefined)
+    ) ?? null
+  )
+}
+
+export function someNestedSchemaComponent(schema, callback) {
+  return (
+    iterateNestedSchemaComponents(
+      schema,
+      (component, name) => (callback(component, name) ? true : undefined)
+    ) ?? false
+  )
+}
+
+export function everyNestedSchemaComponent(schema, callback) {
+  return (
+    iterateNestedSchemaComponents(
+      schema,
+      component => (callback(component) ? undefined : false)
+    ) ?? true
+  )
+}
+
+export function hasNestedSchemaComponents(schema) {
+  return someNestedSchemaComponent(schema, () => true) ?? false
+}
+
+/**
+ * Returns whether `schema` has a component named `name` in its components or
+ * tabs, or in those of its unnested components, e.g. sections without
+ * `nested: true`, which share the data of `schema` without adding their own
+ * name to the data path.
+ */
+export function hasComponentNamed(schema, name) {
+  const found = iterateNestedSchemaComponents(
+    schema,
+    (component, componentName) => {
+      if (
+        isNested(component)
+          ? componentName === name
+          : hasComponentNamed(component, name)
+      ) {
+        return true
+      }
+    }
+  )
+  return !!found
+}
+
+export function isSchema(schema) {
+  return isObject(schema) && isString(schema.type)
+}
+
+export function isForm(schema) {
+  return isSchema(schema) && schema.type === 'form'
+}
+
+export function isView(schema) {
+  return isSchema(schema) && schema.type === 'view'
+}
+
+export function isTab(schema) {
+  return isSchema(schema) && schema.type === 'tab'
+}
+
+export function isPanel(schema) {
+  return isSchema(schema) && schema.type === 'panel'
+}
+
+// Returns whether `schema` is a panel that provides its own data through
+// `schema.data`, e.g. a filters panel, instead of sharing the data of its
+// schema, see `DitoPanel`.
+export function isPanelWithOwnData(schema) {
+  return isPanel(schema) && !!schema.data
+}
+
+export function isMenu(schema) {
+  return isSchema(schema) && schema.type === 'menu'
+}
+
+export function getSchemaIdentifier(schema) {
+  return JSON.stringify(schema)
+}
+
+export function isSingleComponentView(schema) {
+  return (
+    isView(schema) &&
+    isObject(schema.component)
+  )
+}
+
+export function isCompact(schema) {
+  return !!schema.compact
+}
+
+export function isInlined(schema) {
+  return !!(schema.inlined || schema.components)
+}
+
+export function isNested(schema) {
+  return !!(schema.nested || getTypeOptions(schema)?.defaultNested === true)
+}
+
+export function hasLabel(schema, generateLabels) {
+  const { label } = schema
+  return (
+    label !== false && (
+      !!label ||
+      generateLabels && getTypeOptions(schema)?.generateLabel
+    )
+  )
+}
+
+export function omitSpacing(schema) {
+  return !!getTypeOptions(schema)?.omitSpacing
+}
+
+export function getTabSchemas(schema) {
+  return schema?.tabs ? Object.values(schema.tabs) : []
+}
+
+export function getPanelSchemas(schema) {
+  return schema?.panels ? Object.values(schema.panels) : []
+}
+
+export function isObjectSource(schemaOrType) {
+  return getSourceType(schemaOrType) === 'object'
+}
+
+export function isListSource(schemaOrType) {
+  return getSourceType(schemaOrType) === 'list'
+}
+
+/**
+ * Returns whether `schema` is a source with its own resource, whose items are
+ * loaded, validated and submitted through their own forms, separately from
+ * the data that contains them.
+ */
+export function isSourceWithResource(schema) {
+  return !!getSourceType(schema) && !!schema.resource
+}

package/src/utils/schema/types.js

@@ -0,0 +1,34 @@
+import { isObject } from '@ditojs/utils'
+
+const typeComponents = {}
+
+const unknownTypeReported = {}
+
+export function registerTypeComponent(type, component) {
+  typeComponents[type] = component
+}
+
+export function getTypeComponent(type, allowNull = false) {
+  const component = typeComponents[type] || null
+  if (!component && !allowNull && !unknownTypeReported[type]) {
+    // Report each missing type only once, to avoid flooding the console:
+    unknownTypeReported[type] = true
+    throw new Error(`Unknown Dito.js component type: '${type}'`)
+  }
+  return component
+}
+
+function getType(schemaOrType) {
+  return isObject(schemaOrType) ? schemaOrType.type : schemaOrType
+}
+
+export function getTypeOptions(schemaOrType) {
+  return getTypeComponent(getType(schemaOrType), true) ?? null
+}
+
+export function getSourceType(schemaOrType) {
+  return (
+    getTypeOptions(schemaOrType)?.getSourceType?.(getType(schemaOrType)) ??
+    null
+  )
+}

package/src/utils/schema/validation.js

@@ -0,0 +1,142 @@
+import DitoContext from '../../DitoContext.js'
+import * as validators from '../../validators/index.js'
+import { isFunction, isRegExp, asArray, normalizeDataPath } from '@ditojs/utils'
+import { getTypeOptions } from './types.js'
+import { isSourceWithResource } from './structure.js'
+import {
+  getSchemaValue,
+  shouldRenderSchema,
+  processSchemaData
+} from './data.js'
+
+/**
+ * Returns the validations of a component schema, without requiring a
+ * component: the validations of the type's static `getTypeValidations()`
+ * option, `required`, and finally the `schema.rules` overrides, where
+ * `undefined` removes a validation. Schema values are evaluated with `context`.
+ */
+export function getValidations(schema, context) {
+  const validations = {
+    ...getTypeOptions(schema)?.getTypeValidations?.(schema, context)
+  }
+  if (getSchemaValue('required', { type: Boolean, schema, context })) {
+    validations.required = true
+  }
+  // Allow schema to override default rules and add any new ones:
+  for (const [name, setting] of Object.entries(schema.rules || {})) {
+    if (setting === undefined) {
+      delete validations[name]
+    } else {
+      validations[name] = setting
+    }
+  }
+  return validations
+}
+
+/**
+ * Returns the errors of validating `value` against `validations`, in the
+ * format of server errors, `[{ message }]`, with messages without the label
+ * prefix, or an empty array if the value is valid.
+ */
+export function getValueValidationErrors(value, validations) {
+  const errors = []
+  for (const [name, setting] of Object.entries(validations)) {
+    // eslint-disable-next-line import/namespace
+    const validator = validators[name]
+    if (
+      validator &&
+      // Only apply 'required' validator to empty values.
+      // Apply all other validators only to non-empty values.
+      (name === 'required' || value != null && value !== '')
+    ) {
+      const { validate, message } = validator
+      if (!validate(value, setting, validations)) {
+        errors.push({
+          message: isFunction(message)
+            ? message(value, setting, validations)
+            : message
+        })
+      }
+    }
+  }
+  return errors
+}
+
+/**
+ * Validates `data` along the components of `schema`, including tabs, panels
+ * and the nested forms of list and object items, skipping components whose
+ * `if` evaluates to `false` and sources with their own resource. Returns the
+ * errors in the format of server errors, `{ [dataPath]: [{ message }] }`, or
+ * `null` if the data is valid.
+ */
+export function getDataValidationErrors(schema, data, {
+  dataPath = '',
+  component = null,
+  rootData = data
+} = {}) {
+  let errors = null
+
+  const createContext = ({ schema, data, name, dataPath }) =>
+    new DitoContext(component, {
+      schema,
+      value: name != null ? data[name] : undefined,
+      name,
+      data,
+      dataPath,
+      rootData
+    })
+
+  const shouldProcess = entry => (
+    !isSourceWithResource(entry.schema) &&
+    shouldRenderSchema(entry.schema, createContext(entry))
+  )
+
+  const before = entry => {
+    const { schema, data, name, dataPath } = entry
+    const context = createContext(entry)
+    let value = data[name]
+    // Validate the value as displayed, like the components do, see
+    // `ValueMixin.value`:
+    const { format } = schema
+    if (isFunction(format)) {
+      value = format(context)
+    }
+    const validations = getValidations(schema, context)
+    const valueErrors = getValueValidationErrors(value, validations)
+    if (valueErrors.length > 0) {
+      errors ||= {}
+      errors[dataPath] = valueErrors
+    }
+  }
+
+  processSchemaData(schema, data, {
+    dataPath,
+    shouldProcess,
+    before,
+    options: { component, rootData }
+  })
+  return errors
+}
+
+/**
+ * Returns the entries of `errors` whose data paths match `match`, or `null` if
+ * none match. `match` can be a function receiving the data path, a regular
+ * expression, a data path, or an array of data paths.
+ */
+export function getMatchingValidationErrors(errors, match) {
+  let isMatchingDataPath
+  if (isFunction(match)) {
+    isMatchingDataPath = match
+  } else if (isRegExp(match)) {
+    isMatchingDataPath = dataPath => match.test(dataPath)
+  } else {
+    const dataPaths = asArray(match).map(normalizeDataPath)
+    isMatchingDataPath = dataPath => dataPaths.includes(dataPath)
+  }
+  const matchingEntries = Object.entries(errors || {}).filter(
+    ([dataPath]) => isMatchingDataPath(dataPath)
+  )
+  return matchingEntries.length > 0
+    ? Object.fromEntries(matchingEntries)
+    : null
+}

package/src/utils/units.js

@@ -1,5 +1,72 @@
-import { filesize } from 'filesize'
+// Unit prefixes in order of their exponent, shared by parsing and formatting.
+const prefixes = ['', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y']
 
-export function formatFileSize(size) {
-  return filesize(size, { base: 10 })
+/**
+ * Formats a number of bytes like `'1.5 MB'`, using base 10 (1 kB = 1000 bytes)
+ * unless specified. Base 2 uses IEC units (1 KiB = 1024 bytes).
+ */
+export function formatFileSize(size, { base = 10 } = {}) {
+  const multiplier = getMultiplier(base)
+  const absolute = Math.abs(size)
+  let exponent = Math.min(
+    absolute >= 1 ? Math.floor(Math.log(absolute) / Math.log(multiplier)) : 0,
+    prefixes.length - 1
+  )
+  let amount = roundFileSize(absolute, multiplier, exponent)
+  // Rounding can reach the next unit, e.g. 999999 bytes to 1000 kB = 1 MB.
+  if (amount >= multiplier && exponent < prefixes.length - 1) {
+    amount = roundFileSize(absolute, multiplier, ++exponent)
+  }
+  const prefix = prefixes[exponent]
+  const unit = !prefix
+    ? 'B'
+    : base === 10
+      ? `${prefix}B`
+      : `${prefix.toUpperCase()}iB`
+  return `${size < 0 ? '-' : ''}${amount} ${unit}`
+}
+
+/**
+ * Parses file sizes like `'10 MB'`, `'1.5G'`, `'512kb'` or `'100 bytes'` into
+ * a number of bytes, using base 10 (1 kB = 1000 bytes) unless specified.
+ * IEC units like `'10 MiB'` always use base 2 (1 KiB = 1024 bytes).
+ * Bit units are case-sensitive (`Kb` = kilobit), the byte units aren't.
+ */
+export function parseFileSize(input, { base = 10 } = {}) {
+  const [, amountString, unit] = (
+    String(input).match(/^([\d.,]*)\s*(\D*)$/) || []
+  )
+  const amount = parseFloat(amountString?.replace(',', '.'))
+  if (!isFinite(amount)) {
+    throw new Error(`Can't interpret file size: ${input}`)
+  }
+  const multiplier = getMultiplier(/^[kmgtpezy]ib?$/i.test(unit) ? 2 : base)
+  const bitMatch = unit.replace(/^bits?$/, 'b').match(/^([KMGTPEZY]?)b$/)
+  if (bitMatch) {
+    const exponent = prefixes.indexOf(bitMatch[1].replace('K', 'k'))
+    return Math.round(amount * multiplier ** exponent / 8)
+  }
+  const exponent = prefixes.findIndex(
+    prefix => (
+      prefix.toLowerCase() ===
+      unit
+        .toLowerCase()
+        .replace(/^(bytes?|b)$/, '')
+        .replace(/^(\w)(i?b|i)$/, '$1')
+    )
+  )
+  if (exponent >= 0) {
+    return Math.round(amount * multiplier ** exponent)
+  }
+  throw new Error(`Invalid file size unit: ${unit}`)
+}
+
+function getMultiplier(base) {
+  return base === 10 ? 1000 : 1024
+}
+
+function roundFileSize(size, multiplier, exponent) {
+  // Round bytes to integers, larger units to two decimals.
+  const factor = exponent > 0 ? 100 : 1
+  return Math.round(size / multiplier ** exponent * factor) / factor
 }