@kalisio/kdk 2.1.7 → 2.1.8

package/core/client/mixins/mixin.schema-proxy.js

@@ -1,97 +1,97 @@
-import _ from 'lodash'
-import { createQuerablePromise, loadSchema } from '../utils/index.js'
-import { Events } from '../events.js'
-
-export const schemaProxy = {
-  props: {
-    schemaJson: {
-      type: String,
-      default: ''
-    },
-    schemaFunction: {
-      type: Function,
-      default: null
-    },
-    schemaProperties: {
-      type: [String, Array],
-      default: () => []
-    }
-  },
-  data () {
-    return {
-      schema: null
-    }
-  },
-  methods: {
-    getSchema () {
-      return this.schema
-    },
-    getSchemaId () {
-      return _.get(this.schema, '$id', '')
-    },
-    filterSchema () {
-      // We can filter properties in schema
-      const properties = this.schema.properties
-      // Define the properties filter, could be either a joined list (eg query string) or an array
-      let propertiesFilter = (typeof this.schemaProperties === 'string' ? _.split(this.schemaProperties, ',') : this.schemaProperties)
-      if (typeof propertiesFilter === 'string') propertiesFilter = [propertiesFilter]
-      if (propertiesFilter.length > 0) {
-        Object.keys(properties).forEach(property => {
-          if (!propertiesFilter.includes(property)) delete properties[property]
-        })
-        // Update schema ID so that a filtered schema is not similar to a complete one
-        this.schema.$id += propertiesFilter.join()
-        // Filter as well required properties
-        this.schema.required = _.intersection(this.schema.required, propertiesFilter)
-      }
-    },
-    async loadSchemaFromResource (schemaName) {
-      try {
-        this.schema = await loadSchema(schemaName)
-        this.schema = _.cloneDeep(this.schema)
-        // Apply filtering
-        this.filterSchema()
-        return this.schema
-      } catch (error) {
-        Events.emit('error', error)
-        throw error
-      }
-    },
-    async loadSchemaFromJson (json) {
-      try {
-        this.schema = JSON.parse(json)
-        // Apply filtering
-        this.filterSchema()
-        return this.schema
-      } catch (error) {
-        Events.emit('error', error)
-        throw error
-      }
-    },
-    async loadSchemaFromFunction (f) {
-      try {
-        this.schema = await f()
-        // Apply filtering
-        this.filterSchema()
-        return this.schema
-      } catch (error) {
-        Events.emit('error', error)
-        throw error
-      }
-    },
-    loadSchema (schemaName) {
-      // Create a new mixin promise if required
-      // In the JSON schema file we use a $id like 'http:/www.kalisio.xyz/schemas/service.operation-perspective.json#'
-      const schemaChanged = schemaName && !this.getSchemaId().includes(schemaName + '.json')
-      if (!this.schemaPromise || schemaChanged) {
-        // We need to load the schema now
-        this.schemaPromise = createQuerablePromise(this.schemaJson
-          ? this.loadSchemaFromJson(this.schemaJson)
-          : (this.schemaFunction
-              ? this.loadSchemaFromFunction(this.schemaFunction)
-              : this.loadSchemaFromResource(schemaName)))
-      }
-      return this.schemaPromise
-    }
-  }
-}
+import _ from 'lodash'
+import { createQuerablePromise, loadSchema } from '../utils/index.js'
+import { Events } from '../events.js'
+
+export const schemaProxy = {
+  props: {
+    schemaJson: {
+      type: String,
+      default: ''
+    },
+    schemaFunction: {
+      type: Function,
+      default: null
+    },
+    schemaProperties: {
+      type: [String, Array],
+      default: () => []
+    }
+  },
+  data () {
+    return {
+      schema: null
+    }
+  },
+  methods: {
+    getSchema () {
+      return this.schema
+    },
+    getSchemaId () {
+      return _.get(this.schema, '$id', '')
+    },
+    filterSchema () {
+      // We can filter properties in schema
+      const properties = this.schema.properties
+      // Define the properties filter, could be either a joined list (eg query string) or an array
+      let propertiesFilter = (typeof this.schemaProperties === 'string' ? _.split(this.schemaProperties, ',') : this.schemaProperties)
+      if (typeof propertiesFilter === 'string') propertiesFilter = [propertiesFilter]
+      if (propertiesFilter.length > 0) {
+        Object.keys(properties).forEach(property => {
+          if (!propertiesFilter.includes(property)) delete properties[property]
+        })
+        // Update schema ID so that a filtered schema is not similar to a complete one
+        this.schema.$id += propertiesFilter.join()
+        // Filter as well required properties
+        this.schema.required = _.intersection(this.schema.required, propertiesFilter)
+      }
+    },
+    async loadSchemaFromResource (schemaName) {
+      try {
+        this.schema = await loadSchema(schemaName)
+        this.schema = _.cloneDeep(this.schema)
+        // Apply filtering
+        this.filterSchema()
+        return this.schema
+      } catch (error) {
+        Events.emit('error', error)
+        throw error
+      }
+    },
+    async loadSchemaFromJson (json) {
+      try {
+        this.schema = JSON.parse(json)
+        // Apply filtering
+        this.filterSchema()
+        return this.schema
+      } catch (error) {
+        Events.emit('error', error)
+        throw error
+      }
+    },
+    async loadSchemaFromFunction (f) {
+      try {
+        this.schema = await f()
+        // Apply filtering
+        this.filterSchema()
+        return this.schema
+      } catch (error) {
+        Events.emit('error', error)
+        throw error
+      }
+    },
+    loadSchema (schemaName) {
+      // Create a new mixin promise if required
+      // In the JSON schema file we use a $id like 'http:/www.kalisio.xyz/schemas/service.operation-perspective.json#'
+      const schemaChanged = schemaName && !this.getSchemaId().includes(schemaName + '.json')
+      if (!this.schemaPromise || schemaChanged) {
+        // We need to load the schema now
+        this.schemaPromise = createQuerablePromise(this.schemaJson
+          ? this.loadSchemaFromJson(this.schemaJson)
+          : (this.schemaFunction
+              ? this.loadSchemaFromFunction(this.schemaFunction)
+              : this.loadSchemaFromResource(schemaName)))
+      }
+      return this.schemaPromise
+    }
+  }
+}

package/core/client/mixins/mixin.service.js

@@ -1,22 +1,22 @@
-export const service = {
-  props: {
-    contextId: {
-      type: String,
-      default: undefined
-    },
-    service: {
-      type: String,
-      default: ''
-    }
-  },
-
-  methods: {
-    getService () {
-      const service = this.$api.getService(this.service, this.contextId)
-      if (!service) {
-        throw new Error('Cannot retrieve target service ' + this.service)
-      }
-      return service
-    }
-  }
-}
+export const service = {
+  props: {
+    contextId: {
+      type: String,
+      default: undefined
+    },
+    service: {
+      type: String,
+      default: ''
+    }
+  },
+
+  methods: {
+    getService () {
+      const service = this.$api.getService(this.service, this.contextId)
+      if (!service) {
+        throw new Error('Cannot retrieve target service ' + this.service)
+      }
+      return service
+    }
+  }
+}

package/core/client/reader.js

@@ -1,65 +1,65 @@
-import _ from 'lodash'
-import path from 'path-browserify'
-import { Loading } from 'quasar'
-import { i18n } from './i18n.js'
-import { Events } from './events.js'
-
-// Export singleton
-export const Reader = {
-  readers: {},
-  register (mimeTypes, reader) {
-    if (!_.isArray(mimeTypes)) mimeTypes = [mimeTypes]
-    _.forEach(mimeTypes, mimeType => {
-      this.readers[mimeType] = reader
-      reader.mimeType = mimeType
-    })
-  },
-  filter (filelist) {
-    const acceptedFiles = []
-    const additionnalFiles = []
-    // iterate though the files and sort the files
-    for (let i = 0; i < filelist.length; ++i) {
-      const file = filelist[i]
-      // Check whether a reader is assigned to the file type
-      const fileExt = path.extname(file.name).toLowerCase()
-      let reader = this.readers[fileExt]
-      if (reader) {
-        acceptedFiles.push({ reader: fileExt, name: file.name, files: [file] })
-      } else {
-        // Check for additional files to be supported y a reader
-        reader = _.find(this.readers, reader => reader.getAdditionalFiles().includes(fileExt))
-        if (reader) {
-          additionnalFiles.push({ reader: reader.mimeType, file })
-        } else {
-          const error = { message: i18n.t('errors.UNSUPPORTED_FILE_FORMAT', { file: file.name }) }
-          Events.emit('error', error)
-        }
-      }
-    }
-    // process the additional files
-    _.forEach(additionnalFiles, additionnalFile => {
-      const group = _.find(acceptedFiles, acceptedFile => acceptedFile.reader === additionnalFile.reader)
-      if (group) group.files.push(additionnalFile.file)
-      else {
-        const error = { message: i18n.t('errors.UNSUPPORTED_FILE_FORMAT', { file: additionnalFile.name }) }
-        Events.emit('error', error)
-      }
-    })
-    return acceptedFiles
-  },
-  async read (file, options) {
-    const reader = this.readers[file.reader]
-    Loading.show({ message: i18n.t('reader.READING_FILE', { file: file.name }), html: true })
-    try {
-      const content = await reader.read(file.files, options)
-      Loading.hide()
-      return content
-    } catch (error) {
-      Loading.hide()
-      Events.emit('error', error)
-    }
-  },
-  getSupportedFormats () {
-    return Object.keys(this.readers)
-  }
-}
+import _ from 'lodash'
+import path from 'path-browserify'
+import { Loading } from 'quasar'
+import { i18n } from './i18n.js'
+import { Events } from './events.js'
+
+// Export singleton
+export const Reader = {
+  readers: {},
+  register (mimeTypes, reader) {
+    if (!_.isArray(mimeTypes)) mimeTypes = [mimeTypes]
+    _.forEach(mimeTypes, mimeType => {
+      this.readers[mimeType] = reader
+      reader.mimeType = mimeType
+    })
+  },
+  filter (filelist) {
+    const acceptedFiles = []
+    const additionnalFiles = []
+    // iterate though the files and sort the files
+    for (let i = 0; i < filelist.length; ++i) {
+      const file = filelist[i]
+      // Check whether a reader is assigned to the file type
+      const fileExt = path.extname(file.name).toLowerCase()
+      let reader = this.readers[fileExt]
+      if (reader) {
+        acceptedFiles.push({ reader: fileExt, name: file.name, files: [file] })
+      } else {
+        // Check for additional files to be supported y a reader
+        reader = _.find(this.readers, reader => reader.getAdditionalFiles().includes(fileExt))
+        if (reader) {
+          additionnalFiles.push({ reader: reader.mimeType, file })
+        } else {
+          const error = { message: i18n.t('errors.UNSUPPORTED_FILE_FORMAT', { file: file.name }) }
+          Events.emit('error', error)
+        }
+      }
+    }
+    // process the additional files
+    _.forEach(additionnalFiles, additionnalFile => {
+      const group = _.find(acceptedFiles, acceptedFile => acceptedFile.reader === additionnalFile.reader)
+      if (group) group.files.push(additionnalFile.file)
+      else {
+        const error = { message: i18n.t('errors.UNSUPPORTED_FILE_FORMAT', { file: additionnalFile.name }) }
+        Events.emit('error', error)
+      }
+    })
+    return acceptedFiles
+  },
+  async read (file, options) {
+    const reader = this.readers[file.reader]
+    Loading.show({ message: i18n.t('reader.READING_FILE', { file: file.name }), html: true })
+    try {
+      const content = await reader.read(file.files, options)
+      Loading.hide()
+      return content
+    } catch (error) {
+      Loading.hide()
+      Events.emit('error', error)
+    }
+  },
+  getSupportedFormats () {
+    return Object.keys(this.readers)
+  }
+}

package/core/client/readers/index.js

@@ -1,3 +1,3 @@
-export * from './reader.json.js'
-export * from './reader.csv.js'
-export * from './reader.blob.js'
+export * from './reader.json.js'
+export * from './reader.csv.js'
+export * from './reader.blob.js'

package/core/client/readers/reader.blob.js

@@ -1,39 +1,39 @@
-import _ from 'lodash'
-import logger from 'loglevel'
-import { i18n } from '../i18n.js'
-
-export const BLOBReader = {
-  read (files, options) {
-    if (files.length !== 1) {
-      logger.debug('invalid \'files\' arguments')
-      return
-    }
-    const file = files[0]
-    logger.debug(`reading Blob file ${file.name}`)
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader()
-      reader.onloadend = () => {
-        const content = reader.result
-        if (!content) {
-          reject(new Error(i18n.t('errors.INVALID_BLOB_FILE', { file: file.name })))
-          return
-        }
-        resolve(content)
-      }
-      reader.onerror = (error) => {
-        logger.debug(error)
-        reject(new Error(i18n.t('errors.CANNOT_READ_FILE', { file: file.name }), { errors: error }))
-      }
-      const expectedType = _.get(options, 'type', 'arrayBuffer')
-      if (expectedType === 'dataUrl') {
-        reader.readAsDataURL(file)
-      } else {
-        if (expectedType !== 'arrayBuffer') logger.error(`Undefined expected type ${expectedType}. Read as Array buffer.`)
-        reader.readAsArrayBuffer(file)
-      }
-    })
-  },
-  getAdditionalFiles () {
-    return []
-  }
-}
+import _ from 'lodash'
+import logger from 'loglevel'
+import { i18n } from '../i18n.js'
+
+export const BLOBReader = {
+  read (files, options) {
+    if (files.length !== 1) {
+      logger.debug('invalid \'files\' arguments')
+      return
+    }
+    const file = files[0]
+    logger.debug(`reading Blob file ${file.name}`)
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader()
+      reader.onloadend = () => {
+        const content = reader.result
+        if (!content) {
+          reject(new Error(i18n.t('errors.INVALID_BLOB_FILE', { file: file.name })))
+          return
+        }
+        resolve(content)
+      }
+      reader.onerror = (error) => {
+        logger.debug(error)
+        reject(new Error(i18n.t('errors.CANNOT_READ_FILE', { file: file.name }), { errors: error }))
+      }
+      const expectedType = _.get(options, 'type', 'arrayBuffer')
+      if (expectedType === 'dataUrl') {
+        reader.readAsDataURL(file)
+      } else {
+        if (expectedType !== 'arrayBuffer') logger.error(`Undefined expected type ${expectedType}. Read as Array buffer.`)
+        reader.readAsArrayBuffer(file)
+      }
+    })
+  },
+  getAdditionalFiles () {
+    return []
+  }
+}

package/core/client/readers/reader.csv.js

@@ -1,36 +1,36 @@
-import logger from 'loglevel'
-import Papa from 'papaparse'
-import { i18n } from '../i18n.js'
-
-export const CSVReader = {
-  read (files, options) {
-    if (files.length !== 1) {
-      logger.debug('invalid \'files\' arguments')
-      return
-    }
-    const file = files[0]
-    logger.debug(`reading CSV file ${file.name}`)
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader()
-      reader.onloadend = () => {
-        let content = reader.result
-        const papaParseOptions = Object.assign({ skipEmptyLines: true }, options)
-        content = Papa.parse(content, papaParseOptions)
-        if (content.errors.length > 0) {
-          logger.debug(content.errors)
-          reject(new Error(i18n.t('errors.INVALID_CSV_FILE', { file: file.name }), { errors: content.errors }))
-          return
-        }
-        resolve(content)
-      }
-      reader.onerror = (error) => {
-        logger.debug(error)
-        reject(new Error(i18n.t('errors.CANNOT_READ_FILE', { file: file.name }), { errors: error }))
-      }
-      reader.readAsText(file)
-    })
-  },
-  getAdditionalFiles () {
-    return []
-  }
-}
+import logger from 'loglevel'
+import Papa from 'papaparse'
+import { i18n } from '../i18n.js'
+
+export const CSVReader = {
+  read (files, options) {
+    if (files.length !== 1) {
+      logger.debug('invalid \'files\' arguments')
+      return
+    }
+    const file = files[0]
+    logger.debug(`reading CSV file ${file.name}`)
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader()
+      reader.onloadend = () => {
+        let content = reader.result
+        const papaParseOptions = Object.assign({ skipEmptyLines: true }, options)
+        content = Papa.parse(content, papaParseOptions)
+        if (content.errors.length > 0) {
+          logger.debug(content.errors)
+          reject(new Error(i18n.t('errors.INVALID_CSV_FILE', { file: file.name }), { errors: content.errors }))
+          return
+        }
+        resolve(content)
+      }
+      reader.onerror = (error) => {
+        logger.debug(error)
+        reject(new Error(i18n.t('errors.CANNOT_READ_FILE', { file: file.name }), { errors: error }))
+      }
+      reader.readAsText(file)
+    })
+  },
+  getAdditionalFiles () {
+    return []
+  }
+}

package/core/client/readers/reader.json.js

@@ -1,34 +1,34 @@
-import logger from 'loglevel'
-import { i18n } from '../i18n.js'
-
-export const JSONReader = {
-  read (files, options) {
-    if (files.length !== 1) {
-      logger.debug('invalid \'files\' arguments')
-      return
-    }
-    const file = files[0]
-    logger.debug(`reading JSON file ${file.name}`)
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader()
-      reader.onloadend = () => {
-        let content = reader.result
-        try {
-          content = JSON.parse(content)
-        } catch (error) {
-          logger.debug(error)
-          reject(new Error(i18n.t('errors.INVALID_JSON_FILE', { file }), { errors: error }))
-        }
-        resolve(content)
-      }
-      reader.onerror = (error) => {
-        logger.debug(error)
-        reject(new Error(i18n.t('errors.CANNOT_READ_FILE', { file }), { errors: error }))
-      }
-      reader.readAsText(file)
-    })
-  },
-  getAdditionalFiles () {
-    return []
-  }
-}
+import logger from 'loglevel'
+import { i18n } from '../i18n.js'
+
+export const JSONReader = {
+  read (files, options) {
+    if (files.length !== 1) {
+      logger.debug('invalid \'files\' arguments')
+      return
+    }
+    const file = files[0]
+    logger.debug(`reading JSON file ${file.name}`)
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader()
+      reader.onloadend = () => {
+        let content = reader.result
+        try {
+          content = JSON.parse(content)
+        } catch (error) {
+          logger.debug(error)
+          reject(new Error(i18n.t('errors.INVALID_JSON_FILE', { file }), { errors: error }))
+        }
+        resolve(content)
+      }
+      reader.onerror = (error) => {
+        logger.debug(error)
+        reject(new Error(i18n.t('errors.CANNOT_READ_FILE', { file }), { errors: error }))
+      }
+      reader.readAsText(file)
+    })
+  },
+  getAdditionalFiles () {
+    return []
+  }
+}