@ditojs/admin 2.26.1 → 2.27.0

package/src/mixins/SourceMixin.js

@@ -33,9 +33,9 @@ import { raw } from '@ditojs/ui'
 export default {
   mixins: [ItemMixin, ResourceMixin, SchemaParentMixin],
 
-  defaultValue(schema) {
-    return isListSource(schema) ? [] : null
-  },
+  defaultValue: context => (isListSource(context.schema) ? [] : null),
+  // Exclude all sources that have their own resource handling the data.
+  excludeValue: context => !!context.schema.resource,
 
   provide() {
     return {
@@ -321,15 +321,25 @@ export default {
       // https://github.com/vuejs/vue-router/issues/3393#issuecomment-1158470149
       flush: 'post',
       handler(to, from) {
-        if (
-          this.providesData &&
-          from.path === to.path &&
-          from.hash === to.hash
-        ) {
-          // Paths and hashes remain the same, so only queries have changed.
-          // Update filter and reload data without clearing.
-          this.query = to.query
-          this.loadData(false)
+        if (this.providesData) {
+          if (
+            from.path === to.path &&
+            from.hash === to.hash
+          ) {
+            // Paths and hashes remain the same, so only queries have changed.
+            // Update filter and reload data without clearing.
+            this.query = to.query
+            this.loadData(false)
+          } else if (
+            this.meta.reload &&
+            from.path !== to.path &&
+            from.path.startsWith(to.path)
+          ) {
+            // Reload the source when navigating back to a parent-route after
+            // changing data in a child-route.
+            this.meta.reload = false
+            this.loadData(false)
+          }
         }
       }
     },
@@ -464,9 +474,13 @@ export default {
           notify()
         } else {
           const itemId = this.getItemId(this.schema, item, index)
-          const resource = getMemberResource(itemId, this.resource)
+          const method = 'delete'
+          const resource = getMemberResource(
+            itemId,
+            this.getResource({ method })
+          )
           if (resource) {
-            this.handleRequest({ method: 'delete', resource }, err => {
+            this.handleRequest({ method, resource }, err => {
               if (!err) {
                 this.removeItem(item, index)
                 notify()
@@ -617,7 +631,7 @@ export default {
           isListSource(schema) ? param : null
         ),
         component: DitoComponent.component(
-          nested ? 'DitoFormInlined' : 'DitoForm'
+          nested ? 'DitoFormNested' : 'DitoForm'
         ),
         meta: formMeta
       }
@@ -666,7 +680,7 @@ export default {
     }
   },
 
-  processValue(schema, value, dataPath, graph) {
+  processValue({ schema, value, dataPath }, graph) {
     graph.addSource(dataPath, schema)
     return value
   }

package/src/mixins/TextMixin.js

@@ -11,14 +11,15 @@ export default {
     })
   },
 
-  processValue(schema, value) {
+  processValue(context) {
+    let { schema, value } = context
     if (schema.trim && value != null && isString(value)) {
       // Text fields don't necessarily have a `String` value when `format()`
       // without `parse()` is used.
       value = value.trim()
     }
     if (value === '') {
-      value = getDefaultValue(schema)
+      value = getDefaultValue(schema, context)
     }
     return value
   }

package/src/styles/_table.scss

@@ -219,6 +219,6 @@ table.dito-table {
 }
 
 table.dito-table table.dito-table,
-.dito-form-inlined table.dito-table {
+.dito-form-nested table.dito-table {
   margin: 0;
 }

package/src/types/DitoTypeComponent.vue

@@ -22,7 +22,7 @@ export default DitoTypeComponent.register('component', {
   // Override the standard `defaultValue: null` to not set any data for custom
   // components, unless they provide a default value.
   defaultValue: () => undefined, // Callback to override `defaultValue: null`
-  ignoreMissingValue: schema => !('default' in schema),
+  ignoreMissingValue: ({ schema }) => !('default' in schema),
 
   async processSchema(api, schema) {
     await resolveSchemaComponent(schema)

package/src/types/DitoTypeDate.vue

@@ -72,7 +72,7 @@ export default DitoTypeComponent.register(
       }
     },
 
-    processValue(schema, value) {
+    processValue({ value }) {
       return isDate(value) ? value.toISOString() : value
     }
   }

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

@@ -624,37 +624,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 +691,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 +714,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 +788,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 +813,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