@koumoul/vjsf 2.22.0 → 3.0.0-alpha.0

package/lib/utils/options.js

@@ -1,328 +0,0 @@
-import { mdiCalendar, mdiClock, mdiInformation, mdiPlus, mdiPencil, mdiDelete, mdiDotsVertical, mdiContentDuplicate, mdiContentCopy, mdiContentPaste } from '@mdi/js'
-
-export const defaultOptions = {
-  locale: '',
-  defaultLocale: '',
-  rootDisplay: '',
-  objectContainerClass: '',
-  sectionsClass: 'pl-2 pt-2',
-  sectionsTitlesClasses: ['title', 'subtitle-1', 'subtitle-2'],
-  arrayItemsTitlesClasses: ['title', 'subtitle-1', 'subtitle-2'],
-  childrenClass: '',
-  fieldProps: {},
-  fieldColProps: { cols: 12 },
-  readOnlyFieldProps: { hideDetails: true },
-  textFieldProps: {},
-  textareaProps: { filled: true },
-  numberProps: {},
-  sliderProps: {},
-  checkboxProps: {},
-  switchProps: {},
-  comboboxProps: {},
-  selectProps: {},
-  fileInputProps: {},
-  radioGroupProps: {},
-  radioItemProps: {},
-  tabsProps: { grow: true },
-  expansionPanelsProps: { mandatory: true },
-  dialogProps: { maxWidth: 500 },
-  dialogCardProps: {},
-  colorPickerProps: {},
-  timePickerProps: {},
-  datePickerProps: { scrollable: true },
-  arrayItemCardProps: {},
-  arrayItemColProps: { cols: 12 },
-  stepperProps: {},
-  verticalStepperProps: {},
-  tooltipProps: { left: true, openOnHover: false, openOnClick: true },
-  removeAdditionalProperties: true,
-  disableAll: false,
-  hideReadOnly: false,
-  hideReadOnlyLabels: false,
-  hideReadOnlyEmpty: false,
-  hideReadOnlyTooltips: false,
-  deleteReadOnly: false,
-  hideInArrayItem: false,
-  filesAsDataUrl: false,
-  hideTooltips: false,
-  disableSorting: false,
-  sortableOptions: {},
-  context: {},
-  rules: {},
-  initialValidation: 'defined',
-  idPrefix: '',
-  markdownit: {},
-  editMode: 'dialog',
-  arrayOperations: ['create', 'update', 'duplicate', 'copy', 'paste', 'delete'],
-  autofocus: false,
-  httpOptions: {},
-  selectAll: false,
-  autoFixArrayItems: true,
-  useValidator: false,
-  evalMethod: 'propertyExpr',
-  easyMDEOptions: {},
-  maxLengthCounter: true
-}
-
-export const localizedMessages = {
-  en: {
-    required: 'This information is required',
-    noData: 'No matching value found',
-    search: 'Search...',
-    minimum: 'The value must be greater than or equal to {minimum}',
-    exclusiveMinimum: 'The value must be greater than {exclusiveMinimum}',
-    maximum: 'The value must be lower than or equal to {maximum}',
-    exclusiveMaximum: 'The value must be lower than {exclusiveMaximum}',
-    minLength: '{minLength} characters minimum',
-    maxLength: '{maxLength} characters maximum',
-    minItems: 'No less than {minItems} items',
-    maxItems: 'No more than {maxItems} items',
-    pattern: 'The expected pattern is not satisfied',
-    mdeLink1: '[Link title',
-    mdeLink2: '](link url)',
-    mdeImg1: '![](',
-    mdeImg2: 'image url)',
-    mdeTable1: '',
-    mdeTable2: '\n\n| Column 1 | Column 2 | ColoColumnnne 3 |\n| -------- | -------- | -------- |\n| Text     | Text     | Text     |\n\n',
-    bold: 'Bold',
-    italic: 'Italic',
-    heading: 'Title',
-    quote: 'Quote',
-    unorderedList: 'Unordered list',
-    orderedList: 'Ordered list',
-    createLink: 'Create a link',
-    insertImage: 'Insert an image',
-    createTable: 'Create a table',
-    preview: 'Aperçu du rendu',
-    mdeGuide: 'Documentation de la syntaxe',
-    undo: 'Undo',
-    redo: 'Redo',
-    selectAll: 'Select all',
-    stepperContinue: 'continue',
-    openMenu: 'open menu',
-    delete: 'delete',
-    duplicate: 'duplicate',
-    copy: 'copy',
-    paste: 'paste'
-  },
-  fr: {
-    required: 'Cette information est obligatoire',
-    noData: 'Aucun élément correspondant',
-    search: 'Recherchez...',
-    minimum: 'La valeur doit être supérieure ou égale à {minimum}',
-    exclusiveMinimum: 'La valeur doit être supérieure {exclusiveMinimum}',
-    maximum: 'La valeur doit être inférieure ou égale à {maximum}',
-    exclusiveMaximum: 'La valeur doit être inférieure à {exclusiveMaximum}',
-    minLength: '{minLength} caractères minimum',
-    maxLength: '{maxLength} caractères maximum',
-    minItems: 'Au moins {minItems} éléments',
-    maxItems: 'Au plus {maxItems} éléments',
-    pattern: `Le format attendu n'est pas respecté`,
-    mdeLink1: '[titre du lien',
-    mdeLink2: '](adresse du lien)',
-    mdeImg1: '![](',
-    mdeImg2: 'adresse de l\'image)',
-    mdeTable1: '',
-    mdeTable2: '\n\n| Colonne 1 | Colonne 2 | Colonne 3 |\n| -------- | -------- | -------- |\n| Texte     | Texte     | Texte     |\n\n',
-    bold: 'Gras',
-    italic: 'Italique',
-    heading: 'Titre',
-    quote: 'Citation',
-    unorderedList: 'Liste à puce',
-    orderedList: 'Liste numérotée',
-    createLink: 'Créer un lien',
-    insertImage: 'Insérer une image',
-    createTable: 'Créer un tableau',
-    preview: 'Preview',
-    mdeGuide: 'Syntax documentation',
-    undo: 'Défaire',
-    redo: 'Refaire',
-    selectAll: 'Tout sélectionner',
-    stepperContinue: 'continuer',
-    openMenu: 'ouvrir le menu',
-    delete: 'supprimer',
-    duplicate: 'dupliquer',
-    copy: 'copier',
-    paste: 'coller'
-  },
-  es: {
-    required: 'Esta información es requerida',
-    noData: 'No se encontraron valores coincidentes',
-    search: 'Buscar...',
-    minimum: 'El valor debe ser mayor o igual que {minimum}',
-    exclusiveMinimum: 'El valor debe ser mayor que {exclusiveMinimum}',
-    maximum: 'El valor debe ser menor o igual a {maximum}',
-    exclusiveMaximum: 'El valor debe ser inferior a {exclusiveMaximum}',
-    minLength: '{minLength} caracteres mínimo',
-    maxLength: '{maxLength} caractères máximo',
-    minItems: 'Al menos {minItems} articulos',
-    maxItems: 'Hasta {maxItems} articulos',
-    pattern: 'El formato esperado no se respeta',
-    selectAll: 'Seleccionar todo',
-    stepperContinue: 'continuar'
-  },
-  de: {
-    required: 'Diese Informationen sind erforderlich',
-    noData: 'Keine passenden Artikel',
-    search: 'Suche...',
-    minimum: 'Der Wert muss größer oder gleich {minimum} sein',
-    exclusiveMinimum: 'Der Wert muss größer als {exclusiveMinimum} sein',
-    maximum: 'Der Wert muss kleiner oder gleich {maximum} sein',
-    exclusiveMaximum: 'Der Wert muss kleiner als {exclusiveMaximum} sein',
-    minLength: 'Mindestens {minLength} Zeichen',
-    maxLength: 'Maximal {maxLength} Zeichen',
-    minItems: 'Mindestens {minItems} Elemente',
-    maxItems: 'Bis zu {maxItems} Artikel',
-    pattern: 'Das erwartete Format wird nicht eingehalten',
-    selectAll: 'Wählen Sie Alle',
-    stepperContinue: 'weiter'
-  },
-  ar: {
-    required: 'هذه المعلومة مطلوبة',
-    noData: 'لم يتم العثور على قيمة',
-    search: 'جاري البحث...',
-    minimum: '{exclusiveMinimum} القيمة يجب أن تكون أكبر من', // TODO, same as exclusiveMinimum waiting for a proper translation
-    exclusiveMinimum: '{exclusiveMinimum} القيمة يجب أن تكون أكبر من',
-    maximum: '{maximum} القيمة يجب أن تكون أقل من', // TODO, same as exclusiveMaximum waiting for a proper translation
-    exclusiveMaximum: '{exclusiveMaximum} القيمة يجب أن تكون أقل من',
-    minLength: '{minLength} الحد الأدنى للحروف المطلوبة هو',
-    maxLength: '{maxLength} الحد الأقصى للحروف المطلوبة هو',
-    minItems: 'قطع {minItems} لا يمكن اختيار أقل من ',
-    maxItems: 'قطع {maxItems} لا يمكن اختيار أكثر من ',
-    pattern: 'لا يوجد تشابه مع النموذج المطلوب',
-    selectAll: 'اختر الكل',
-    stepperContinue: 'استمر'
-  },
-  tr: {
-    required: 'Zorunlu alan',
-    noData: 'Bilgi yok',
-    search: 'Arıyor...',
-    minimum: 'Değer {minimum} dan büyük olmalı',
-    exclusiveMinimum: 'Değer {exclusiveMinimum} dan büyük olmalı',
-    maximum: 'Değer, {maximum} değerinden küçük veya ona eşit olmalıdır',
-    exclusiveMaximum: 'Değer {exclusiveMaximum} dan küçük olmalı',
-    minLength: '{minLength} asgari karakter sayısı',
-    maxLength: '{maxLength} azami  karakter sayısı',
-    minItems: 'En az seçenek sayısı {minItems}',
-    maxItems: 'En çok seçenek sayısı {maxItems}',
-    pattern: 'İstenilen paten tutmuyor',
-    selectAll: 'Hepsini seç',
-    stepperContinue: 'devam et'
-  },
-  nl: {
-    required: 'Deze informatie is vereist',
-    noData: 'Geen overeenkomstig resultaat gevonden',
-    search: 'Zoeken...',
-    minimum: 'De waarde moet groter zijn dan of gelijk zijn aan {minimum}',
-    exclusiveMinimum: 'Waarde moet meer zijn dan {exclusiveMinimum}',
-    maximum: 'De waarde moet lager zijn dan of gelijk zijn aan {maximum}',
-    exclusiveMaximum: 'Waarde moet minder zijn dan {exclusiveMaximum}',
-    minLength: 'Minimaal {minLength} tekens',
-    maxLength: 'Maximaal {maxLength} tekens',
-    minItems: 'Minimaal {minItems} antwoorden',
-    maxItems: 'Maximaal {maxItems} antwoorden',
-    pattern: 'Invoer voldoet niet aan verwachte patroon',
-    selectAll: 'Selecteer alles',
-    stepperContinue: 'doorgaan'
-  },
-  ja: {
-    required: 'この情報は必須です。',
-    noData: '一致する値はありません。',
-    search: '検索...',
-    minimum: '値は{minimum}以上である必要があります。',
-    exclusiveMinimum: '値は{exclusiveMinimum}より大きい必要があります。',
-    maximum: '値は{maximum}以下である必要があります。',
-    exclusiveMaximum: '値は{exclusiveMaximum}より小さい必要があります。',
-    minLength: '最小文字数は{minLength}です。',
-    maxLength: '最大文字数は{maxLength}です。',
-    minItems: '最小項目数は{minItems}です。',
-    maxItems: '最大項目数は{maxItems}です。',
-    pattern: '期待される様式を満たしていません。',
-    mdeTable2: '\n\n| Column 1 | Column 2 | ColoColumnnne 3 |\n| -------- | -------- | -------- |\n| Text     | Text     | Text     |\n\n',
-    bold: '太字',
-    italic: 'イタリック',
-    heading: 'タイトル',
-    quote: '引用',
-    unorderedList: '順序なしリスト',
-    orderedList: '順序付きリスト',
-    createLink: 'リンクを生成',
-    insertImage: '画像を挿入',
-    createTable: 'テーブル作成',
-    preview: 'プレビュー',
-    mdeGuide: '構文に関するドキュメント',
-    undo: '元に戻す',
-    redo: 'やり直し',
-    selectAll: '全選択',
-    stepperContinue: 'コンティニュー',
-    openMenu: 'メニューを開く',
-    delete: '削除',
-    duplicate: '重複',
-    copy: 'コーピー',
-    paste: 'ペースト'
-  }
-}
-
-export const formats = {
-  time: (time, locale) => {
-    const date = new Date(`${new Date().toISOString().split('T')[0]}T${time}`)
-    return new Date(date.getTime() + (date.getTimezoneOffset() * 60000)).toLocaleTimeString(locale)
-  },
-  date: (dateStr, locale) => {
-    const date = new Date(dateStr)
-    return new Date(date.getTime() + (date.getTimezoneOffset() * 60000)).toLocaleDateString(locale)
-  },
-  'date-time': (dateTime, locale) => {
-    return new Date(dateTime).toLocaleString(locale)
-  }
-}
-
-export const iconSets = {
-  mdiSvg: {
-    calendar: mdiCalendar,
-    clock: mdiClock,
-    info: mdiInformation,
-    add: mdiPlus,
-    edit: mdiPencil,
-    delete: mdiDelete,
-    arrayMenu: mdiDotsVertical,
-    duplicate: mdiContentDuplicate,
-    copy: mdiContentCopy,
-    paste: mdiContentPaste
-  },
-  mdi: {
-    calendar: 'mdi-calendar',
-    clock: 'mdi-clock',
-    info: 'mdi-information',
-    add: 'mdi-plus',
-    edit: 'mdi-pencil',
-    delete: 'mdi-delete',
-    arrayMenu: 'mdi-dots-vertical',
-    duplicate: 'mdi-plus-circle-multiple-outline',
-    copy: 'mdi-content-copy',
-    paste: 'mdi-content-paste'
-  },
-  md: {
-    calendar: 'event',
-    clock: 'clock',
-    info: 'info',
-    add: 'add',
-    edit: 'create',
-    delete: 'delete',
-    arrayMenu: 'more_vert',
-    duplicate: 'control_point_duplicate',
-    copy: 'copy',
-    paste: 'paste'
-  },
-  fa: {
-    calendar: 'fa-calendar',
-    clock: 'fa-clock',
-    info: 'fa-info',
-    add: 'fa-plus',
-    edit: 'fa-edit',
-    delete: 'fa-trash',
-    arrayMenu: 'fa-ellipsis-vertical',
-    duplicate: 'fa-layer-plus',
-    copy: 'fa-copy',
-    paste: 'fa-paste'
-  }
-}

package/lib/utils/rules.js

@@ -1,81 +0,0 @@
-import { deepEqual } from 'fast-equals'
-
-export const getRules = (schema, fullSchema, options, required, isOneOfSelect) => {
-  const rules = []
-  if (required) {
-    rules.push((val) => (val !== undefined && val !== null && val !== '') || options.messages.required)
-  }
-  if (fullSchema.type === 'array' && fullSchema.minItems !== undefined) {
-    const msg = options.messages.minItems.replace('{minItems}', fullSchema.minItems.toLocaleString(options.locale))
-    rules.push((val) => (!val || val.length >= fullSchema.minItems) || msg)
-  }
-  if (fullSchema.type === 'array' && fullSchema.maxItems !== undefined) {
-    const msg = options.messages.maxItems.replace('{maxItems}', fullSchema.maxItems.toLocaleString(options.locale))
-    rules.push((val) => (!val || val.length <= fullSchema.maxItems) || msg)
-  }
-  if (fullSchema.type === 'string' && fullSchema.minLength !== undefined) {
-    const msg = options.messages.minLength.replace('{minLength}', fullSchema.minLength.toLocaleString(options.locale))
-    rules.push((val) => (val === undefined || val === null || (!required && val === '') || val.length >= fullSchema.minLength) || msg)
-  }
-  if (fullSchema.type === 'string' && fullSchema.maxLength !== undefined) {
-    const msg = options.messages.maxLength.replace('{maxLength}', fullSchema.maxLength.toLocaleString(options.locale))
-    rules.push((val) => (val === undefined || val === null || val.length <= fullSchema.maxLength) || msg)
-  }
-  if (fullSchema.type === 'string' && fullSchema.patternRegexp !== undefined) {
-    const msg = options.messages.pattern.replace('{pattern}', fullSchema.pattern)
-    rules.push((val) => (val === undefined || val === null || val === '' || !!val.match(fullSchema.patternRegexp)) || msg)
-  }
-  if (['number', 'integer'].includes(fullSchema.type) && fullSchema.maximum !== undefined) {
-    const msg = options.messages.maximum.replace('{maximum}', fullSchema.maximum.toLocaleString(options.locale))
-    rules.push((val) => (val === undefined || val === null || val <= fullSchema.maximum) || msg)
-  }
-  if (['number', 'integer'].includes(fullSchema.type) && fullSchema.exclusiveMaximum !== undefined) {
-    const msg = options.messages.exclusiveMaximum.replace('{exclusiveMaximum}', fullSchema.exclusiveMaximum.toLocaleString(options.locale))
-    rules.push((val) => (val === undefined || val === null || val < fullSchema.exclusiveMaximum) || msg)
-  }
-  if (['number', 'integer'].includes(fullSchema.type) && fullSchema.minimum !== undefined) {
-    const msg = options.messages.minimum.replace('{minimum}', fullSchema.minimum.toLocaleString(options.locale))
-    rules.push((val) => (val === undefined || val === null || val >= fullSchema.minimum) || msg)
-  }
-  if (['number', 'integer'].includes(fullSchema.type) && fullSchema.exclusiveMinimum !== undefined) {
-    const msg = options.messages.exclusiveMinimum.replace('{exclusiveMinimum}', fullSchema.exclusiveMinimum.toLocaleString(options.locale))
-    rules.push((val) => (val === undefined || val === null || val > fullSchema.exclusiveMinimum) || msg)
-  }
-  if (fullSchema.enum) {
-    rules.push((val) => (val === undefined || val === null || !!fullSchema.enum.find(item => deepEqual(item, val))) || '')
-  }
-  if (fullSchema.type === 'array' && fullSchema.items.enum) {
-    rules.push((val) => (val === undefined || val === null || !val.find(valItem => !fullSchema.items.enum.find(item => deepEqual(item, valItem)))) || '')
-  }
-  if (isOneOfSelect && fullSchema.type !== 'array') {
-    rules.push((val) => (val === undefined || val === null || !!fullSchema.oneOf.find(item => deepEqual(item.const, val))) || '')
-  }
-  if (isOneOfSelect && fullSchema.type === 'array') {
-    rules.push((val) => (val === undefined || val === null || !val.find(valItem => !fullSchema.items.oneOf.find(item => deepEqual(item.const, valItem)))) || '')
-  }
-
-  // ajv validation
-  if (options.validator && options.useValidator) {
-    rules.push(getAjvRule(schema, options.validator))
-  }
-
-  const customRules = (fullSchema['x-rules'] || []).map(rule => {
-    if (typeof rule === 'string') {
-      const ruleFunction = options.rules && options.rules[rule]
-      if (!ruleFunction) console.error(`rule ${rule} is referenced but not define in options`)
-      return ruleFunction
-    } else {
-      console.error(`rule should be a string, received ${typeof rule}`)
-    }
-  }).filter(rule => !!rule)
-  return rules.concat(customRules)
-}
-
-const getAjvRule = (schema, validator, locale) => {
-  const validate = validator(schema)
-  return (val) => {
-    if (val === null || val === undefined) return true
-    const error = validate(val)
-    return !error || error
-  }
-}

package/lib/utils/schema.js

@@ -1,100 +0,0 @@
-// Some util functions around schema manipulation to reduce size of the Property component
-import copy from 'fast-copy'
-
-const schemaUtils = {}
-
-export default schemaUtils
-
-const objectToArray = (obj) => Object.keys(obj || {}).map(key => ({ ...obj[key], key }))
-
-const getDeepKey = (obj, key) => {
-  const keys = key.split('.')
-  for (let i = 0; i < keys.length; i++) {
-    if ([null, undefined].includes(obj)) break
-    obj = obj[keys[i]]
-  }
-  return obj
-}
-
-const extendSchema = (schema, subSchema) => {
-  schema.required = schema.required.concat(subSchema.required || [])
-  schema.properties = schema.properties.concat(objectToArray(subSchema.properties))
-  if (subSchema.oneOf) schema.oneOf = (schema.oneOf || []).concat(subSchema.oneOf)
-  if (subSchema.allOf) schema.allOf = (schema.allOf || []).concat(subSchema.allOf)
-}
-
-schemaUtils.prepareFullSchema = (schema, value, options) => {
-  const fullSchema = copy(schema)
-
-  if (fullSchema.pattern) fullSchema.patternRegexp = new RegExp(fullSchema.pattern)
-
-  if (!fullSchema.type && fullSchema.properties) fullSchema.type = 'object'
-
-  // detect type from combination info
-  if (!fullSchema.type) {
-    const combination = fullSchema.anyOf || fullSchema.oneOf || fullSchema.allOf
-    const typedCombinationItem = combination && combination.find(c => !!c.type)
-    if (typedCombinationItem) fullSchema.type = typedCombinationItem.type
-  }
-
-  // manage null type in an array, for example ['string', 'null']
-  if (Array.isArray(fullSchema.type)) {
-    fullSchema.nullable = fullSchema.type.includes('null')
-    fullSchema.type = fullSchema.type.find(t => t !== 'null')
-    if (fullSchema.nullable && fullSchema.enum) fullSchema.enum = fullSchema.enum.filter(v => v !== null)
-  }
-
-  // add index as key in case of tuples
-  if (fullSchema.items && Array.isArray(fullSchema.items)) {
-    fullSchema.items.forEach((item, i) => {
-      item.key = '' + i
-    })
-  }
-
-  // enum with a single item can be used as another way to express const
-  if (fullSchema.enum && fullSchema.enum.length === 1) {
-    fullSchema.const = fullSchema.enum[0]
-    delete fullSchema.enum
-  }
-
-  if (fullSchema.type !== 'object') return fullSchema
-
-  // Properties as array for easier loops
-  fullSchema.properties = objectToArray(fullSchema.properties)
-  fullSchema.required = fullSchema.required || []
-  fullSchema.dependencies = fullSchema.dependencies || {}
-
-  // Extend schema based on satisfied dependencies
-  if (fullSchema.dependencies) {
-    Object.keys(fullSchema.dependencies).forEach(depKey => {
-      const dep = fullSchema.dependencies[depKey]
-      // cases where dependency does not apply
-      if (!value) return
-      const val = getDeepKey(value, depKey)
-      if ([null, undefined, false].includes(val)) return
-      if (Array.isArray(val) && val.length === 0) return
-      if (typeof val === 'object' && Object.keys(val).length === 0) return
-
-      // dependency applies
-      extendSchema(fullSchema, dep)
-    })
-  }
-
-  // extend schema based on conditions
-  if (fullSchema.if) {
-    if (!options.validator) {
-      console.error('v-jsf - The conditional if/then/else syntax requires the ajv or other validator option.')
-    } else {
-      // TODO: store this somewhere so that it is not re-compiled many times
-      const validate = options.validator(fullSchema.if)
-      const error = validate(value)
-      if (!error && fullSchema.then) {
-        extendSchema(fullSchema, fullSchema.then)
-      }
-      if (error && fullSchema.else) {
-        extendSchema(fullSchema, fullSchema.else)
-      }
-    }
-  }
-  return fullSchema
-}

package/lib/utils/select.js

@@ -1,141 +0,0 @@
-// Some util functions around select components preparation to reduce size of the component
-import { deepEqual } from 'fast-equals'
-
-const selectUtils = {}
-export default selectUtils
-
-selectUtils.fetchRawItems = async (fullOptions, fullSchema, fromUrl, q) => {
-  const url = fromUrl.replace('{q}', encodeURIComponent(q || ''))
-  const res = await fullOptions.httpLib.get(url, fullOptions.httpOptions)
-  const body = res.data || res.body
-  const items = fullSchema['x-itemsProp'] ? body[fullSchema['x-itemsProp']] : body
-  if (!Array.isArray(items)) throw new Error(`Result of http fetch ${url} is not an array`)
-  return items
-}
-
-// from raw data to items usable in select components
-selectUtils.getSelectItems = (rawSelectItems, fullSchema, itemKey, itemIcon) => {
-  const selectItems = []
-
-  if (!rawSelectItems) {
-    // nothing to do
-  } else if (
-    (fullSchema.type === 'object' && fullSchema.properties && Object.keys(fullSchema.properties).length) ||
-    (fullSchema.type === 'array' && fullSchema.items && fullSchema.items.type === 'object' && fullSchema.items.properties && Object.keys(fullSchema.items.properties).length)
-  ) {
-    const keys = fullSchema.properties ? fullSchema.properties.map(p => p.key) : Object.keys(fullSchema.items.properties)
-    rawSelectItems.forEach(item => {
-      const filteredItem = {}
-      keys.forEach(key => {
-        const property = fullSchema.properties ? fullSchema.properties.find(p => p.key === key) : fullSchema.items.properties[key]
-        if (item[key] !== undefined) {
-          filteredItem[key] = item[key]
-          // special case as seen in _prefilled_array_wrong_type.js
-          if (property.type === 'string') filteredItem[key] = '' + filteredItem[key]
-        }
-        if ('default' in property && key in filteredItem) filteredItem[key] = property.default
-        if ('const' in property) filteredItem[key] = property.const
-      })
-      selectItems.push(filteredItem)
-    })
-  } else {
-    rawSelectItems.forEach(item => {
-      if (typeof item === 'object') {
-        selectItems.push(item)
-      } else {
-        const itemObject = { [itemKey]: item }
-        if (itemIcon) itemObject[itemIcon] = item
-        selectItems.push(itemObject)
-      }
-    })
-  }
-  return selectItems
-}
-
-const matchItem = (selectItem, item, itemKey) => {
-  if ([null, undefined].includes(selectItem)) return false
-  if ([null, undefined].includes(item)) return false
-  return deepEqual(selectItem[itemKey], item[itemKey])
-}
-
-// TODO: this is not very rigorous because we have no way of knowing that the stored value will be properly
-// matched with a simple "q" params.. but it kinda gets the job done.. let's think about it some more at some point in the future
-const missingValuesCache = []
-const fetchMissingValue = async (fullOptions, fullSchema, itemKey, fromUrl, value) => {
-  const valueFromCache = missingValuesCache.find(cv => deepEqual(cv.key, [itemKey, fromUrl, value]))
-  if (valueFromCache) return valueFromCache.result || value
-  const rawItems = await selectUtils.fetchRawItems(fullOptions, fullSchema, fromUrl, value[itemKey])
-  const result = rawItems.find(item => matchItem(item, value, itemKey))
-  missingValuesCache.push({ key: [itemKey, fromUrl, value], result })
-  return result || value
-}
-
-// add the current value to the select items so that they can be displayed
-selectUtils.fillSelectItems = async (fullOptions, fullSchema, value, selectItems, itemKey, itemTitle, fromUrl, returnObject) => {
-  if (!value) return
-  if (Array.isArray(value)) {
-    for (let val of value.map(item => item).reverse()) {
-      if (!returnObject) val = { [itemKey]: val }
-      if (!selectItems.find(selectItem => matchItem(selectItem, val, itemKey))) {
-        if (!returnObject && fromUrl) val = await fetchMissingValue(fullOptions, fullSchema, itemKey, fromUrl, val)
-        selectItems.push(val)
-      }
-    }
-  } else {
-    if (!returnObject) value = { [itemKey]: value }
-    if (!selectItems.find(selectItem => matchItem(selectItem, value, itemKey))) {
-      if (!returnObject && fromUrl) value = await fetchMissingValue(fullOptions, fullSchema, itemKey, fromUrl, value)
-      selectItems.push(value)
-    }
-  }
-}
-
-selectUtils.fillList = (fullSchema, value, selectItems, itemKey) => {
-  if (!value) return
-  if (!selectItems.length) return []
-  value = [...value]
-  // Prefill the lists (not actual select component, but an array instead)
-  selectItems.forEach(selectItem => {
-    if (!value.find(modelItem => matchItem(selectItem, modelItem, itemKey))) {
-      value.push(selectItem)
-    }
-  })
-  // also remove deprecated items
-  value.forEach((item, i) => {
-    if (!selectItems.find(selectItem => matchItem(selectItem, item, itemKey))) {
-      value[i] = null
-    }
-  })
-  return value.filter(item => !!item)
-}
-
-selectUtils.isOneOfSelect = (fullSchema) => {
-  if (!fullSchema) return
-  if (fullSchema.type === 'array' && fullSchema.items && ['string', 'integer', 'number'].includes(fullSchema.items.type) && (fullSchema.items.oneOf || fullSchema.items.anyOf)) return true
-  if (['string', 'integer', 'number'].includes(fullSchema.type) && fullSchema.oneOf && fullSchema.oneOf[0] && fullSchema.oneOf[0].const !== undefined) return true
-  if (['string', 'integer', 'number'].includes(fullSchema.type) && fullSchema.anyOf && fullSchema.anyOf[0] && fullSchema.anyOf[0].const !== undefined) return true
-  return false
-}
-
-// get an object title if x-itemTitles is defined, handle direct values or values matched to a label through a oneOf/anyof
-selectUtils.getObjectTitle = (item, itemTitle, fullSchema) => {
-  if (!itemTitle) return null
-  const titlePropertySchema = fullSchema.items && fullSchema.items.properties && fullSchema.items.properties[itemTitle]
-  if (titlePropertySchema) {
-    const oneOfSelect = selectUtils.isOneOfSelect(titlePropertySchema)
-    if (oneOfSelect) {
-      const of = titlePropertySchema.anyOf || titlePropertySchema.oneOf
-      const ofItem = of.find(ofItem => ofItem.const === item[itemTitle] || (ofItem.enum && ofItem.enum[0] === item[itemTitle]))
-      if (ofItem) return ofItem.title
-    }
-  }
-
-  if (fullSchema.items && (fullSchema.items.oneOf || fullSchema.items.anyOf)) {
-    const of = fullSchema.items.oneOf || fullSchema.items.anyOf
-    const props = of[0].properties
-    const key = Object.keys(props).find(p => 'const' in props[p])
-    const ofItem = of.find(ofItem => ofItem.properties[key].const === item[itemTitle])
-    if (ofItem) return ofItem.title
-  }
-  return item[itemTitle]
-}