@ditojs/admin 2.26.2 → 2.27.1

package/src/types/DitoTypeSection.vue

@@ -23,7 +23,7 @@ import { getItemFormSchema, processSchemaComponents } from '../utils/schema.js'
 // @vue/component
 export default DitoTypeComponent.register('section', {
   defaultValue: () => undefined, // Callback to override `defaultValue: null`
-  ignoreMissingValue: schema => !schema.nested && !('default' in schema),
+  ignoreMissingValue: ({ schema }) => !schema.nested && !('default' in schema),
   defaultNested: false,
   generateLabel: false,
 

package/src/types/DitoTypeText.vue

@@ -38,7 +38,7 @@ export default DitoTypeComponent.register(
     components: { InputField },
     nativeField: true,
     textField: true,
-    ignoreMissingValue: schema => schema.type === 'password',
+    ignoreMissingValue: ({ schema }) => schema.type === 'password',
 
     computed: {
       inputType() {

package/src/types/DitoTypeUpload.vue

@@ -452,7 +452,7 @@ export default DitoTypeComponent.register('upload', {
     }
   },
 
-  processValue(schema, value) {
+  processValue({ schema, value }) {
     // Filter out all newly added files that weren't actually uploaded.
     const files = asFiles(value)
       .map(({ upload, ...file }) => (!upload || upload.success ? file : null))

package/src/utils/resource.js

@@ -1,4 +1,4 @@
-import { isObject, isString, pickBy } from '@ditojs/utils'
+import { isFunction, isObject, isString, pickBy } from '@ditojs/utils'
 
 export function hasResource(schema) {
   return !!getResource(schema.resource)
@@ -6,6 +6,9 @@ export function hasResource(schema) {
 
 export function getResource(resource, defaults = {}) {
   const { parent, ...defs } = defaults
+  if (isFunction(resource)) {
+    resource = resource(defaults)
+  }
   resource = isObject(resource)
     ? { ...defs, ...resource }
     : isString(resource)

package/src/utils/schema.js

@@ -242,33 +242,36 @@ export async function resolveSchemaComponents(schemas) {
   await mapConcurrently(Object.values(schemas || {}), resolveSchemaComponent)
 }
 
-const processedSchemas = new WeakSet()
+const processedSchemaDepths = new WeakMap()
 export async function processSchemaComponents(
   api,
   schema,
   routes = null,
-  level = 0
+  level = 0,
+  maxDepth = 1
 ) {
-  if (schema && !processedSchemas.has(schema)) {
-    processedSchemas.add(schema)
-
-    const promises = []
-    const process = (component, name, relativeLevel) => {
-      promises.push(
-        processSchemaComponent(
-          api,
-          component,
-          name,
-          routes,
-          level + relativeLevel
+  if (schema) {
+    const depth = processedSchemaDepths.get(schema) ?? 0
+    if (depth < maxDepth) {
+      processedSchemaDepths.set(schema, depth + 1)
+      const promises = []
+      const process = (component, name, relativeLevel) => {
+        promises.push(
+          processSchemaComponent(
+            api,
+            component,
+            name,
+            routes,
+            level + relativeLevel
+          )
         )
-      )
-    }
+      }
 
-    iterateNestedSchemaComponents(schema, process)
-    iterateSchemaComponents(getPanelSchemas(schema), process)
+      iterateNestedSchemaComponents(schema, process)
+      iterateSchemaComponents(getPanelSchemas(schema), process)
 
-    await Promise.all(promises)
+      await Promise.all(promises)
+    }
   }
 }
 
@@ -368,7 +371,7 @@ export function processRouteSchema(api, schema, name, fullPath = null) {
 
 export async function processForms(api, schema, level) {
   // First resolve the forms and store the results back on the schema.
-  let { form, forms, components } = schema
+  let { form, forms, components, maxDepth = 1 } = schema
   if (forms) {
     forms = schema.forms = await resolveSchemas(forms, form =>
       processForm(api, form)
@@ -387,7 +390,7 @@ export async function processForms(api, schema, level) {
   forms ||= { default: form } // Only used for process loop below.
   const children = []
   for (const form of Object.values(forms)) {
-    await processSchemaComponents(api, form, children, level)
+    await processSchemaComponents(api, form, children, level, maxDepth)
   }
   return children
 }
@@ -624,37 +627,53 @@ export function shouldRenderSchema(schema, context) {
   )
 }
 
-export function getDefaultValue(schema) {
+function getContext(context) {
+  return isFunction(context) ? context() : context
+}
+
+export function getDefaultValue(schema, context) {
   // Support default values both on schema and on component level.
   // NOTE: At the time of creation, components may not be instantiated, (e.g. if
   // entries are created through nested forms, the parent form isn't mounted) so
   // we can't use `dataPath` to get to components, and the `defaultValue` from
   // there. That's why `defaultValue` is defined statically in the components:
-  const defaultValue = schema.default
-  const value =
-    defaultValue !== undefined
-      ? defaultValue
+  const defaultValue =
+    schema.default !== undefined
+      ? schema.default
       : getTypeOptions(schema)?.defaultValue
-  return isFunction(value)
-    ? // TODO: Pass `DitoContext` here too, with the (incomplete) item and al
-      // the other bits!
-      value(schema)
-    : clone(value)
+  return isFunction(defaultValue)
+    ? defaultValue(getContext(context))
+    : clone(defaultValue)
 }
 
-export function ignoreMissingValue(schema) {
-  const typeOptions = getTypeOptions(schema)
-  return !!(
-    typeOptions?.excludeValue || typeOptions?.ignoreMissingValue?.(schema)
-  )
+export function shouldExcludeValue(schema, context) {
+  const excludeValue =
+    schema.exclude !== undefined
+      ? schema.exclude
+      : getTypeOptions(schema)?.excludeValue
+  return isFunction(excludeValue)
+    ? excludeValue(getContext(context))
+    : !!excludeValue
+}
+
+export function shouldIgnoreMissingValue(schema, context) {
+  return !!getTypeOptions(schema)?.ignoreMissingValue?.(getContext(context))
 }
 
 export function setDefaultValues(schema, data = {}, component) {
   const options = { component, rootData: data }
 
-  const processBefore = (schema, data, name) => {
-    if (!(name in data) && !ignoreMissingValue(schema)) {
-      data[name] = getDefaultValue(schema)
+  const processBefore = (schema, data, name, dataPath) => {
+    const context = () =>
+      new DitoContext(component, {
+        schema,
+        name,
+        data,
+        dataPath,
+        rootData: options.rootData
+      })
+    if (!(name in data) && !shouldIgnoreMissingValue(schema, context)) {
+      data[name] = getDefaultValue(schema, context)
     }
   }
 
@@ -675,20 +694,20 @@ export function computeValue(schema, data, name, dataPath, {
   component = null,
   rootData = component?.rootData
 } = {}) {
+  const context = () =>
+    new DitoContext(component, {
+      schema,
+      // Override value to prevent endless recursion through calling the
+      // getter for `this.value` in `DitoContext`:
+      value: data[name],
+      name,
+      data,
+      dataPath,
+      rootData
+    })
   const { compute } = schema
   if (compute) {
-    const value = compute(
-      new DitoContext(component, {
-        schema,
-        // Override value to prevent endless recursion through calling the
-        // getter for `this.value` in `DitoContext`:
-        value: data[name],
-        name,
-        data,
-        dataPath,
-        rootData
-      })
-    )
+    const value = compute(getContext(context))
     if (value !== undefined) {
       // Access `data[name]` directly to update the value without calling
       // parse():
@@ -698,10 +717,10 @@ export function computeValue(schema, data, name, dataPath, {
     }
   }
   // If the value is still missing after compute, set the default for it:
-  if (!(name in data) && !ignoreMissingValue(schema)) {
+  if (!(name in data) && !shouldIgnoreMissingValue(schema, context)) {
     // TODO: Fix side-effects
     // eslint-disable-next-line vue/no-side-effects-in-computed-properties
-    data[name] = getDefaultValue(schema)
+    data[name] = getDefaultValue(schema, context)
   }
   // Now access the value. This is important for reactivity and needs to
   // happen after all prior manipulation of `data[name]`, see above:
@@ -772,13 +791,11 @@ export function processData(schema, sourceSchema, data, dataPath, {
   }
 
   const processAfter = (schema, data, name, dataPath, processedData) => {
-    const { wrapPrimitives, exclude, process } = schema
+    const { wrapPrimitives, process } = schema
     let value = processedData[name]
 
-    const typeOptions = getTypeOptions(schema)
-
     // NOTE: We don't cache this context, since `value` is changing.
-    const getContext = () =>
+    const context = () =>
       new DitoContext(component, {
         schema,
         value,
@@ -799,23 +816,18 @@ export function processData(schema, sourceSchema, data, dataPath, {
 
     // Each component type can provide its own static `processValue()` method
     // to convert the data for storage.
-    const processValue = typeOptions?.processValue
+    const processValue = getTypeOptions(schema)?.processValue
     if (processValue) {
-      value = processValue(schema, value, dataPath, graph)
+      value = processValue(getContext(context), graph)
     }
 
     // Handle the user's `process()` callback next, if one is provided, so that
     // it can modify data in `processedData` even if it provides `exclude: true`
     if (process) {
-      value = process(getContext())
+      value = process(getContext(context))
     }
 
-    if (
-      typeOptions?.excludeValue ||
-      // Support functions next to booleans for `schema.exclude`:
-      exclude === true ||
-      isFunction(exclude) && exclude(getContext())
-    ) {
+    if (shouldExcludeValue(schema, context)) {
       delete processedData[name]
     } else {
       processedData[name] = value