@operato/dataset 1.0.0-beta.7 → 1.0.0

package/src/usecase/ccp/ox-data-use-case-ccp.ts

@@ -0,0 +1,147 @@
+import i18next from 'i18next' // Since this is a common module, @operato/i18n was deliberately avoided.
+
+import { DataItem, EvaluationResult, UseCaseDefinition } from '../../types'
+import { OxDataUseCase } from '../ox-data-use-case.js'
+
+export class OxDataUseCaseCCP extends OxDataUseCase {
+  getSpecification(dataItem: DataItem): UseCaseDefinition {
+    return {
+      name: 'CCP',
+      description: 'Critical Control Point Data Spec',
+      help: '',
+      specs: [
+        {
+          type: 'ccp-limits' /* A value which seperates acceptability from unacceptability */,
+          label: 'critical-limits',
+          name: 'criticalLimits',
+          property: dataItem
+        },
+        {
+          type: 'ccp-limits',
+          label: 'target-limits',
+          name: 'targetLimits',
+          property: dataItem
+        }
+      ]
+    }
+  }
+
+  evaluate(spec: any, values: any | any[]): EvaluationResult | undefined {
+    if (!spec || typeof values === 'undefined') {
+      return
+    }
+
+    if (!(values instanceof Array)) {
+      values = [values]
+    }
+
+    const {
+      minimum: criticalMinimum,
+      maximum: criticalMaximum,
+      acceptables: criticalAcceptables
+    } = spec['criticalLimits'] || {}
+
+    const {
+      minimum: targetMinimum,
+      maximum: targetMaximum,
+      acceptables: targetAcceptables
+    } = spec['targetLimits'] || {}
+
+    var oos = false
+    var ooc = false
+
+    for (let i = 0; i < values.length; i++) {
+      const value = values[i]
+
+      if (criticalMinimum != null && value < criticalMinimum) {
+        oos = true
+        break
+      }
+
+      if (criticalMaximum != null && value > criticalMaximum) {
+        oos = true
+        break
+      }
+
+      if (criticalAcceptables != null && !criticalAcceptables.includes(value)) {
+        oos = true
+        break
+      }
+    }
+
+    for (let i = 0; i < values.length; i++) {
+      const value = values[i]
+
+      if (targetMinimum != null && value < targetMinimum) {
+        ooc = true
+        break
+      }
+
+      if (targetMaximum != null && value > targetMaximum) {
+        ooc = true
+        break
+      }
+
+      if (targetAcceptables != null && !targetAcceptables.includes(value)) {
+        ooc = true
+        break
+      }
+    }
+
+    return { oos, ooc }
+  }
+
+  elaborateUseCaseSpec(limits: any): string | undefined {
+    if (!limits) {
+      return
+    }
+
+    var text = ''
+
+    const {
+      minimum: criticalMinimum,
+      maximum: criticalMaximum,
+      acceptables: criticalAcceptables
+    } = limits['criticalLimits'] || {}
+
+    if (criticalMinimum != null || criticalMaximum != null || criticalAcceptables != null) {
+      text += `${i18next.t('label.critical-limits')}\n`
+    }
+
+    if (criticalMinimum != null) {
+      text += `\t${i18next.t('label.minimum value')} : ${criticalMinimum}\n`
+    }
+    if (criticalMaximum != null) {
+      text += `\t${i18next.t('label.maximum value')} : ${criticalMaximum}\n`
+    }
+    if (criticalAcceptables != null) {
+      text += `\t${i18next.t('label.acceptables')} : ${
+        criticalAcceptables instanceof Array ? criticalAcceptables.join(', ') : criticalAcceptables
+      }\n`
+    }
+
+    const {
+      minimum: targetMinimum,
+      maximum: targetMaximum,
+      acceptables: targetAcceptables
+    } = limits['targetLimits'] || {}
+
+    if (targetMinimum != null || targetMaximum != null || targetAcceptables != null) {
+      text += `${i18next.t('label.target-limits')}\n`
+    }
+
+    if (targetMinimum != null) {
+      text += `\t${i18next.t('label.minimum value')} : ${targetMinimum}\n`
+    }
+    if (targetMaximum != null) {
+      text += `\t${i18next.t('label.maximum value')} : ${targetMaximum}\n`
+    }
+    if (targetAcceptables != null) {
+      text += `\t${i18next.t('label.acceptables')} : ${
+        targetAcceptables instanceof Array ? targetAcceptables.join(', ') : targetAcceptables
+      }\n`
+    }
+
+    return text
+  }
+}

package/src/usecase/ccp/ox-input-ccp-limits.ts

@@ -0,0 +1,161 @@
+/**
+ * @license Copyright © HatioLab Inc. All rights reserved.
+ */
+
+import { css, html, LitElement } from 'lit'
+import { customElement, property, query, queryAll } from 'lit/decorators.js'
+
+import { i18next } from '@operato/i18n'
+
+export enum DataItemType {
+  number = 'number',
+  text = 'text',
+  boolean = 'boolean',
+  select = 'select',
+  file = 'file'
+}
+
+export type CcpLimitValue = {
+  minimum?: number
+  maximum?: number
+  acceptables?: string[]
+}
+
+/**
+ element for CCP limits
+ 
+ Example:
+ 
+   <ox-input-ccp-limits
+     .value=${value}
+     .type=${type}>
+   </ox-input-ccp-limits>
+ */
+@customElement('ox-input-ccp-limits')
+export class OxInputCcpLimits extends LitElement {
+  static styles = css`
+    :host {
+      display: flex;
+      flex-direction: column;
+      align-content: center;
+    }
+
+    label {
+      margin: 0 var(--margin-default) var(--margin-default) 0;
+    }
+
+    label div > * {
+      vertical-align: middle;
+    }
+
+    button {
+      width: 20px;
+      text-align: center;
+    }
+
+    div[name],
+    input[type='checkbox'] + span {
+      display: inline-block;
+      font: var(--label-font);
+      color: var(--label-color);
+      text-align: right;
+    }
+    input,
+    select {
+      border: var(--input-field-border);
+      border-radius: var(--input-field-border-radius);
+      padding: var(--input-field-padding);
+      font: var(--input-field-font);
+    }
+
+    input[type='checkbox'] {
+      width: initial;
+    }
+    input[checked] + span {
+      font-weight: bold;
+    }
+    [unit],
+    [value] {
+      display: inline-block;
+      opacity: 0.7;
+      font: var(--form-sublabel-font);
+    }
+    [properties] {
+      font: var(--input-field-font);
+      color: var(--label-color);
+    }
+  `
+
+  @property({ type: Object }) value: CcpLimitValue = {}
+  @property({ type: String }) type: DataItemType = DataItemType.number
+  @property({ type: String }) unit?: string
+  @property({ type: Array }) options: { options?: { text: string; value: string }[] } = {}
+
+  @query('[name=minimum]') minimum!: HTMLInputElement
+  @query('[name=maximum]') maximum!: HTMLInputElement
+  @queryAll('[type=checkbox]:checked') checkedAll!: NodeListOf<HTMLInputElement>
+
+  firstUpdated() {
+    this.renderRoot.addEventListener('change', this.onChange.bind(this))
+  }
+
+  render() {
+    const { minimum, maximum, acceptables = [] } = this.value || {}
+
+    return html`
+      <div>
+        ${this.type === DataItemType.number
+          ? html`
+              <label>
+                <div name>${i18next.t('text.minimum value')}</div>
+                <input type="number" name="minimum" .value=${minimum} />
+                <div unit>${this.unit}</div>
+              </select>
+              </label>
+              <label>
+                <div name>${i18next.t('text.maximum value')}</div>
+                <input type="number" name="maximum" .value=${maximum} />
+                <div unit>${this.unit}</div>
+              </label>
+            </div>
+            `
+          : this.type === DataItemType.select
+          ? html`
+              <!-- <div>Acceptables</div> -->
+              ${this.options?.options?.map(
+                option => html`
+                  <div>
+                    <input type="checkbox" data-value=${option.value} ?checked=${acceptables.includes(option.value)} />
+                    <span>${option.text}</span>
+                    <span value>(${option.value})</span>
+                  </div>
+                `
+              )}
+          </div>
+          `
+          : html` <div properties>${i18next.t('text.no properties to set')}</div> `}
+      </div>
+    `
+  }
+
+  private onChange(e: Event) {
+    if (this.type === DataItemType.number) {
+      this.value = {
+        minimum: this.minimum.valueAsNumber,
+        maximum: this.maximum.valueAsNumber
+      }
+    } else if (this.type === DataItemType.select) {
+      this.value = {
+        acceptables: Array.from(this.checkedAll).map(checked => {
+          const x = checked.getAttribute('data-value')!
+          console.log(x)
+          return x
+        })
+      }
+    } else {
+      this.value = {}
+    }
+
+    this.dispatchEvent(new CustomEvent('change', { bubbles: true, composed: true, detail: this.value }))
+  }
+}

package/src/usecase/ccp/ox-property-editor-ccp-limits.ts

@@ -0,0 +1,23 @@
+import './ox-input-ccp-limits.js'
+
+import { html } from 'lit'
+import { customElement } from 'lit/decorators.js'
+
+import { OxPropertyEditor, PropertySpec } from '@operato/property-editor'
+
+@customElement('ox-property-editor-ccp-limits')
+export class OxPropertyEditorCcpLimits extends OxPropertyEditor {
+  editorTemplate(value: any, spec: PropertySpec) {
+    const { type, options, unit } = spec.property || {}
+
+    return html`
+      <ox-input-ccp-limits
+        id="editor"
+        .value=${value}
+        .type=${type}
+        .unit=${unit}
+        .options=${options}
+      ></ox-input-ccp-limits>
+    `
+  }
+}

package/src/{ox-data-use-case.ts → usecase/ox-data-use-case.ts}

@@ -1,4 +1,4 @@
-import { DataItem, DataItemSpecSet, DataSet, EvaluationResult } from './types'
+import { DataItem, DataSet, DataSpecLimitSet, EvaluationResult, UseCaseDefinition } from '../types'
 
 export abstract class OxDataUseCase {
   static registry: { [name: string]: OxDataUseCase } = {}
@@ -19,39 +19,33 @@ export abstract class OxDataUseCase {
     return OxDataUseCase.registry[name]
   }
 
-  public static elaborateDataItemSpec(dataSet: DataSet, dataItem: DataItem): string {
-    if (!dataSet.useCase) {
-      return ''
-    }
+  public static elaborateDataItemSpec(useCaseNames: string[], spec: DataSpecLimitSet): string {
+    var texts: string[] = []
 
-    const useCaseNames = dataSet.useCase.split(',').map(useCaseName => useCaseName.trim())
-    const useCases = useCaseNames.map(useCaseName => OxDataUseCase.getUseCase(useCaseName)).filter(useCase => !!useCase)
-
-    var texts = []
-
-    for (let j = 0; j < useCases.length; j++) {
-      const useCase = useCases[j]
+    useCaseNames.forEach(useCaseName => {
+      const useCase = OxDataUseCase.getUseCase(useCaseName)
       if (!useCase) {
-        continue
+        return
       }
 
-      const specs = dataItem.spec?.[dataSet.useCase]
-      if (!specs) {
-        continue
+      const limits = spec?.[useCaseName]
+      if (!limits) {
+        return
       }
 
-      const result = useCase.elaborateUseCaseSpec(dataItem.spec)
+      const result = useCase.elaborateUseCaseSpec(limits)
       if (!result) {
-        continue
+        return
       }
 
+      texts.push(`[ ${useCaseName} ]`)
       texts.push(result)
-    }
+    })
 
     return texts.join('\n')
   }
 
-  public static evaluate(dataSet: DataSet, dataItems: DataItem[], data: any): EvaluationResult | undefined {
+  public static evaluate(dataSet: DataSet, dataItems: DataItem[], data: any): EvaluationResult {
     var ooc = false
     var oos = false
 
@@ -86,7 +80,7 @@ export abstract class OxDataUseCase {
           continue
         }
 
-        const result = useCase?.evaluate(specs, values)
+        const result = useCase!.evaluate(specs, values)
 
         if (result) {
           ooc ||= result.ooc
@@ -98,22 +92,10 @@ export abstract class OxDataUseCase {
     return { ooc, oos }
   }
 
-  public static evaluateItem(dataSet: DataSet, dataItem: DataItem, values: any | any[]): EvaluationResult | undefined {
+  public static evaluateItem(spec: DataSpecLimitSet, values: any | any[]): EvaluationResult | undefined {
     var ooc = false
     var oos = false
 
-    if (!dataSet.useCase) {
-      return { ooc, oos }
-    }
-
-    const useCaseNames = dataSet.useCase.split(',').map(useCaseName => useCaseName.trim())
-    const useCases = useCaseNames.map(useCaseName => OxDataUseCase.getUseCase(useCaseName)).filter(useCase => !!useCase)
-
-    const { active, tag } = dataItem
-    if (!active || !tag) {
-      return
-    }
-
     if (typeof values === 'undefined') {
       return // TODO what if in case no value ?
     }
@@ -122,26 +104,30 @@ export abstract class OxDataUseCase {
       values = [values]
     }
 
-    for (let j = 0; j < useCases.length; j++) {
-      const useCase = useCases[j]
+    const useCaseNames = Object.keys(spec || {})
+
+    if (useCaseNames.length === 0) {
+      return { ooc, oos }
+    }
 
-      const specs = dataItem.spec?.[dataSet.useCase]
-      if (!specs) {
+    useCaseNames.forEach(useCaseName => {
+      const useCase = OxDataUseCase.getUseCase(useCaseName)
+      if (!useCase) {
         return
       }
 
-      const result = useCase?.evaluate(specs, values)
+      const result = useCase?.evaluate(spec[useCaseName], values)
 
       if (result) {
         ooc ||= result.ooc
         oos ||= result.oos
       }
-    }
+    })
 
     return { ooc, oos }
   }
 
   public abstract evaluate(specs: any, values: any[]): EvaluationResult | undefined
   public abstract elaborateUseCaseSpec(spec: any): string | undefined
-  public abstract getSpecification(dataItem: DataItem): DataItemSpecSet
+  public abstract getSpecification(dataItem: DataItem): UseCaseDefinition
 }

package/src/usecase/qc/index.ts

@@ -0,0 +1,10 @@
+/* Here, only the common module of client and server is imported/exported. Be careful not to use a module dedicated to client or server. */
+
+import { OxDataUseCase } from '../ox-data-use-case.js'
+import { OxDataUseCaseQC } from './ox-data-use-case-qc.js'
+
+// OxPropertyEditor.register({
+//   'qc-limits': 'ox-property-editor-qc-limits'
+// })
+
+OxDataUseCase.registerUseCase('QC', new OxDataUseCaseQC())

package/src/usecase/qc/ox-data-use-case-qc.ts

@@ -0,0 +1,72 @@
+import i18next from 'i18next' // Since this is a common module, @operato/i18n was deliberately avoided.
+
+import { DataItem, EvaluationResult, UseCaseDefinition } from '../../types.js'
+import { OxDataUseCase } from '../ox-data-use-case.js'
+
+export class OxDataUseCaseQC implements OxDataUseCase {
+  getSpecification(dataItem: DataItem): UseCaseDefinition {
+    return {
+      name: 'QC',
+      description: 'Quality Control Data Spec',
+      help: '',
+      specs: [
+        {
+          type: 'qc-limits' /* 'A value which seperates acceptability from unacceptability' */,
+          label: 'pass-limits',
+          name: 'passLimits',
+          property: dataItem
+        }
+      ]
+    }
+  }
+
+  evaluate(spec: any, values: any[]): EvaluationResult {
+    const { minimum, maximum, acceptables } = spec['passLimits']
+
+    for (let i = 0; i < values.length; i++) {
+      const value = values[i]
+
+      if (minimum != null && value < minimum) {
+        return { oos: true, ooc: true }
+      }
+
+      if (maximum != null && value > maximum) {
+        return { oos: true, ooc: true }
+      }
+
+      if (acceptables != null && !acceptables.includes(value)) {
+        return { oos: true, ooc: true }
+      }
+    }
+
+    return { oos: false, ooc: false }
+  }
+
+  elaborateUseCaseSpec(limits: any): string | undefined {
+    if (!limits) {
+      return
+    }
+
+    var text = ''
+
+    const { minimum, maximum, acceptables } = limits['passLimits'] || {}
+
+    if (minimum != null || maximum != null || acceptables != null) {
+      text += `${i18next.t('label.pass-limits')}\n`
+    }
+
+    if (minimum != null) {
+      text += `\t${i18next.t('label.minimum value')} : ${minimum}\n`
+    }
+    if (maximum != null) {
+      text += `\t${i18next.t('label.maximum value')} : ${maximum}\n`
+    }
+    if (acceptables != null) {
+      text += `\t${i18next.t('label.acceptables')} : ${
+        acceptables instanceof Array ? acceptables.join(', ') : acceptables
+      }\n`
+    }
+
+    return text
+  }
+}

package/src/usecase/qc/ox-input-qc-limits.ts

@@ -0,0 +1,161 @@
+/**
+ * @license Copyright © HatioLab Inc. All rights reserved.
+ */
+
+import { css, html, LitElement } from 'lit'
+import { customElement, property, query, queryAll } from 'lit/decorators.js'
+
+import { i18next } from '@operato/i18n'
+
+export enum DataItemType {
+  number = 'number',
+  text = 'text',
+  boolean = 'boolean',
+  select = 'select',
+  file = 'file'
+}
+
+export type QcLimitValue = {
+  minimum?: number
+  maximum?: number
+  acceptables?: string[]
+}
+
+/**
+ element for QC limits
+ 
+ Example:
+ 
+   <ox-input-qc-limits
+     .value=${value}
+     .type=${type}>
+   </ox-input-qc-limits>
+ */
+@customElement('ox-input-qc-limits')
+export class OxInputQcLimits extends LitElement {
+  static styles = css`
+    :host {
+      display: flex;
+      flex-direction: column;
+      align-content: center;
+    }
+
+    label {
+      margin: 0 var(--margin-default) var(--margin-default) 0;
+    }
+
+    label div > * {
+      vertical-align: middle;
+    }
+
+    button {
+      width: 20px;
+      text-align: center;
+    }
+
+    div[name],
+    input[type='checkbox'] + span {
+      display: inline-block;
+      font: var(--label-font);
+      color: var(--label-color);
+      text-align: right;
+    }
+    input,
+    select {
+      border: var(--input-field-border);
+      border-radius: var(--input-field-border-radius);
+      padding: var(--input-field-padding);
+      font: var(--input-field-font);
+    }
+
+    input[type='checkbox'] {
+      width: initial;
+    }
+    input[checked] + span {
+      font-weight: bold;
+    }
+    [unit],
+    [value] {
+      display: inline-block;
+      opacity: 0.7;
+      font: var(--form-sublabel-font);
+    }
+    [properties] {
+      font: var(--input-field-font);
+      color: var(--label-color);
+    }
+  `
+
+  @property({ type: Object }) value: QcLimitValue = {}
+  @property({ type: String }) type: DataItemType = DataItemType.number
+  @property({ type: String }) unit?: string
+  @property({ type: Array }) options: { options?: { text: string; value: string }[] } = {}
+
+  @query('[name=minimum]') minimum!: HTMLInputElement
+  @query('[name=maximum]') maximum!: HTMLInputElement
+  @queryAll('[type=checkbox]:checked') checkedAll!: NodeListOf<HTMLInputElement>
+
+  firstUpdated() {
+    this.renderRoot.addEventListener('change', this.onChange.bind(this))
+  }
+
+  render() {
+    const { minimum, maximum, acceptables = [] } = this.value || {}
+
+    return html`
+      <div>
+        ${this.type === DataItemType.number
+          ? html`
+              <label>
+                <div name>${i18next.t('text.minimum value')}</div>
+                <input type="number" name="minimum" .value=${minimum} />
+                <div unit>${this.unit}</div>
+              </select>
+              </label>
+              <label>
+                <div name>${i18next.t('text.maximum value')}</div>
+                <input type="number" name="maximum" .value=${maximum} />
+                <div unit>${this.unit}</div>
+              </label>
+            </div>
+            `
+          : this.type === DataItemType.select
+          ? html`
+              <!-- <div>Acceptables</div> -->
+              ${this.options?.options?.map(
+                option => html`
+                  <div>
+                    <input type="checkbox" data-value=${option.value} ?checked=${acceptables.includes(option.value)} />
+                    <span>${option.text}</span>
+                    <span value>(${option.value})</span>
+                  </div>
+                `
+              )}
+          </div>
+          `
+          : html` <div properties>${i18next.t('text.no properties to set')}</div> `}
+      </div>
+    `
+  }
+
+  private onChange(e: Event) {
+    if (this.type === DataItemType.number) {
+      this.value = {
+        minimum: this.minimum.valueAsNumber,
+        maximum: this.maximum.valueAsNumber
+      }
+    } else if (this.type === DataItemType.select) {
+      this.value = {
+        acceptables: Array.from(this.checkedAll).map(checked => {
+          const x = checked.getAttribute('data-value')!
+          console.log(x)
+          return x
+        })
+      }
+    } else {
+      this.value = {}
+    }
+
+    this.dispatchEvent(new CustomEvent('change', { bubbles: true, composed: true, detail: this.value }))
+  }
+}