reneco-advanced-input-module 0.0.1-beta.1 → 0.0.1-beta.2

package/src/utils/schema-converter.ts

@@ -1,494 +0,0 @@
-import { FormSchema, FormField, FormSchemaFieldsOnly, FormSchemaFieldsOnlyExtended, FormFieldExtended } from '../types/form-schema.types';
-
-export class SchemaConverter {
-  /**
-   * Convert XML form definition to JSON schema
-   */
-  static convertXmlToJsonLegacy(xmlForm: string): FormSchema {
-    try {
-      const parser = new DOMParser();
-      const xmlDoc = parser.parseFromString(xmlForm, 'text/xml');
-      
-      if (xmlDoc.querySelector('parsererror')) {
-        throw new Error('Invalid XML format');
-      }
-
-      const schema: FormSchema = {
-        schema: {}
-      };
-
-      // Extract form title and description
-      const formElement = xmlDoc.querySelector('form');
-      if (formElement) {
-        schema.title = formElement.getAttribute('title') || undefined;
-        schema.description = formElement.getAttribute('description') || undefined;
-      }
-
-      // Process input fields
-      const inputs = xmlDoc.querySelectorAll('input, select, textarea');
-      inputs.forEach(input => {
-        const name = input.getAttribute('name');
-        if (!name) return;
-
-        const field: FormField = {
-          type: this.mapXmlTypeToJsonTypeLegacy(input.tagName.toLowerCase(), input.getAttribute('type')),
-          title: input.getAttribute('title') || input.getAttribute('placeholder') || name,
-          description: input.getAttribute('description') || undefined,
-          required: input.hasAttribute('required'),
-          default: input.getAttribute('value') || undefined
-        };
-
-        // Handle select options
-        if (input.tagName.toLowerCase() === 'select') {
-          const options = Array.from(input.querySelectorAll('option')).map(option => 
-            option.textContent || option.getAttribute('value') || ''
-          );
-          if (options.length > 0) {
-            field.options = options;
-          }
-        }
-
-        // Handle validation attributes
-        const min = input.getAttribute('min');
-        const max = input.getAttribute('max');
-        const pattern = input.getAttribute('pattern');
-
-        if (min) field.min = parseFloat(min);
-        if (max) field.max = parseFloat(max);
-        if (pattern) field.pattern = pattern;
-
-        schema.schema[name] = field;
-      });
-
-      return schema;
-    } catch (error) {
-      throw new Error(`XML to JSON conversion failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Convert JSON schema to XML form definition
-   */
-  static convertJsonToXmlLegacy(jsonForm: FormSchema): string {
-    try {
-      const doc = document.implementation.createDocument('', '', null);
-      const form = doc.createElement('form');
-      
-      if (jsonForm.title) {
-        form.setAttribute('title', jsonForm.title);
-      }
-      if (jsonForm.description) {
-        form.setAttribute('description', jsonForm.description);
-      }
-
-      Object.entries(jsonForm.schema).forEach(([fieldName, field]) => {
-        // Inject default value from root if present
-        const valueFromRoot = (jsonForm as any)[fieldName];
-        const fieldWithDefault = {
-          ...field,
-          default: field.default ?? valueFromRoot // field.default has priority
-        };
-
-        const element = this.createXmlElementLegacy(doc, fieldName, fieldWithDefault);
-        if (element) {
-          form.appendChild(element);
-        }
-      });
-
-      doc.appendChild(form);
-
-      const serializer = new XMLSerializer();
-      return serializer.serializeToString(doc);
-    } catch (error) {
-      throw new Error(`JSON to XML conversion failed: ${error.message}`);
-    }
-  }
-
-  private static mapXmlTypeToJsonTypeLegacy(tagName: string, type: string | null): FormField['type'] {
-    switch (tagName) {
-      case 'select':
-        return 'select';
-      case 'textarea':
-        return 'string';
-      case 'input':
-        switch (type) {
-          case 'number':
-          case 'range':
-            return 'number';
-          case 'date':
-          case 'datetime-local':
-          case 'time':
-            return 'date';
-          case 'checkbox':
-            return 'boolean';
-          default:
-            return 'string';
-        }
-      default:
-        return 'string';
-    }
-  }
-
-  private static createXmlElementLegacy(doc: Document, fieldName: string, field: FormField): Element | null {
-    let element: Element;
-
-    switch (field.type) {
-      case 'select':
-        element = doc.createElement('select');
-        if (field.options) {
-          field.options.forEach(option => {
-            const optionElement = doc.createElement('option');
-            optionElement.setAttribute('value', option);
-            optionElement.textContent = option;
-            // Set selected if it matches the default value
-            if (field.default !== undefined && field.default === option) {
-              optionElement.setAttribute('selected', 'true');
-            }
-            element.appendChild(optionElement);
-          });
-        }
-        break;
-
-      case 'boolean':
-        element = doc.createElement('input');
-        element.setAttribute('type', 'checkbox');
-        if (field.default === true || field.default === 'true') {
-          element.setAttribute('checked', 'true');
-        }
-        break;
-
-      case 'number':
-        element = doc.createElement('input');
-        element.setAttribute('type', 'number');
-        if (field.min !== undefined) element.setAttribute('min', field.min.toString());
-        if (field.max !== undefined) element.setAttribute('max', field.max.toString());
-        if (field.default !== undefined) element.setAttribute('value', field.default.toString());
-        break;
-
-      case 'date':
-        element = doc.createElement('input');
-        element.setAttribute('type', 'date');
-        if (field.default !== undefined) element.setAttribute('value', field.default.toString());
-        break;
-
-      default: // string, text, etc.
-        element = doc.createElement('input');
-        element.setAttribute('type', 'text');
-        if (field.default !== undefined) element.setAttribute('value', field.default.toString());
-    }
-
-    element.setAttribute('name', fieldName);
-    element.setAttribute('title', field.title);
-
-    if (field.description) {
-      element.setAttribute('description', field.description);
-    }
-    if (field.required) {
-      element.setAttribute('required', 'true');
-    }
-    if (field.pattern) {
-      element.setAttribute('pattern', field.pattern);
-    }
-
-    return element;
-  }
-
-  
-  /**
-   * Convert new XML form definition to JSON schema
-   */
-  static async convertXmlToJson(xmlForm: string, classificationRootURL: string = "http://localhost", lang: 'fr'|'en' = 'en'): Promise<FormSchemaFieldsOnly> {
-    try {
-      const parser = new DOMParser();
-      const xmlDoc = parser.parseFromString(xmlForm, 'text/xml');
-
-      if (xmlDoc.querySelector('parsererror')) {
-        throw new Error('Invalid XML format');
-      }
-
-      // Root Xforms element (optional)
-      const xforms = xmlDoc.querySelector('Xforms');
-      if (!xforms) throw new Error('No Xforms root element found');
-
-      const fields = xforms.querySelectorAll('Fields');
-      if (fields.length === 0) throw new Error('No Fields elements found');
-
-      const schema: FormSchemaFieldsOnly = {
-        fields: {}
-      };
-
-      for (const fieldEl of Array.from(fields)) {
-        // Read key info
-        const name = fieldEl.querySelector('SystemName')?.textContent?.trim();
-        if (!name) return;
-
-        const helpText = fieldEl.querySelector('HelpText')?.textContent?.trim();
-        const defaultValue = fieldEl.querySelector('DefaultValue')?.textContent;
-        const enabledText = fieldEl.querySelector('Enabled')?.textContent?.trim().toLowerCase() || 'true';
-        const isEnabled = enabledText === 'true';
-
-        // keep as memory
-        const field_ID = fieldEl.querySelector('ID')?.textContent;
-        const field_TFie_PK_ID = fieldEl.querySelector('TFie_PK_ID')?.textContent;
-        const field_TVal_PK_ID = fieldEl.querySelector('TVal_PK_ID')?.textContent;
-        const field_TFIn_PK_ID = fieldEl.querySelector('TFIn_PK_ID')?.textContent;
-        const field_isForm = fieldEl.querySelector('isForm')?.textContent;
-        const field_LabelText = fieldEl.querySelector('LabelText')?.textContent;
-        const field_SystemName = fieldEl.querySelector('SystemName')?.textContent;
-        const field_CssStyle = fieldEl.querySelector('CssStyle')?.textContent;
-        const field_ControlType = fieldEl.querySelector('ControlType')?.textContent || 'TextBox';
-        const field_ValidationRequired = fieldEl.querySelector('ValidationRequired')?.textContent;
-        const field_ValidationMin = fieldEl.querySelector('ValidationMin')?.textContent;
-        const field_ValidationMax = fieldEl.querySelector('ValidationMax')?.textContent;
-        const field_Mask = fieldEl.querySelector('Mask')?.textContent;
-        const field_TypeId = fieldEl.querySelector('TypeId')?.textContent;
-        const field_Unit = fieldEl.querySelector('Unit')?.textContent;
-        const field_TFie_Fullpath = fieldEl.querySelector('TFie_Fullpath')?.textContent;
-        const field_TVal_FK_Parent_ID = fieldEl.querySelector('TVal_FK_Parent_ID')?.textContent;
-
-        const field: FormFieldExtended = {
-          type: this.mapControlTypeToJsonType(field_ControlType),
-          title: field_LabelText,
-          description: helpText,
-          required: field_ValidationRequired?.toLowerCase() === 'required',
-          default: defaultValue || undefined,
-
-          realType: field_ControlType,
-
-          Enabled: isEnabled,
-          ID: field_ID,
-          TFie_PK_ID: field_TFie_PK_ID,
-          TVal_PK_ID: field_TVal_PK_ID,
-          TFIn_PK_ID: field_TFIn_PK_ID,
-          isForm: field_isForm,
-          LabelText: field_LabelText,
-          SystemName: field_SystemName,
-          CssStyle: field_CssStyle,
-          ControlType: field_ControlType,
-          ValidationRequired: field_ValidationRequired,
-          ValidationMin: field_ValidationMin,
-          ValidationMax: field_ValidationMax,
-          Mask: field_Mask,
-          TypeId: field_TypeId,
-          Unit: field_Unit,
-          TFie_Fullpath: field_TFie_Fullpath,
-          TVal_FK_Parent_ID: field_TVal_FK_Parent_ID
-        };
-
-        // Handle select options
-        if (field.type.toLowerCase() === 'select') {
-          try {
-            const response = await fetch(`${classificationRootURL}/ng/api/v1/classification/getList/${field.ControlType.toLowerCase() == 'termpicker' ? "Position" : "Thesaurus"}/?StartNodeID=${field_TypeId}`);
-            if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
-
-            const data = await response.json();
-            if (Array.isArray(data)) {
-              const options = data.map(item => ({
-                value: item.ID,
-                label: item.System_Name
-              }));
-              if (options.length > 0) {
-                field.pickerOptions = options;
-                // TODO on degage les quotes simples temporairement, a corriger
-                field.options = options.map(option => option.label.replace("'", ""));
-              }
-            } else {
-              console.error("Unexpected API response format:", data);
-            }
-          } catch (error) {
-            console.error("Error fetching classification data:", error);
-          }
-        }
-
-        if (field_ValidationMin) field.min = parseFloat(field_ValidationMin);
-        if (field_ValidationMax) field.max = parseFloat(field_ValidationMax);
-        if (field_Mask) field.pattern = field_Mask;
-
-        // Optional: Add any other fields you want to track, e.g. min, max, pattern (not clearly in your XML)
-        // You could also add the raw ControlType for round-trip fidelity if you want
-
-        schema.fields[field_ID] = field;
-      };
-
-      return schema;
-    } catch (error) {
-      throw new Error(`XML to JSON conversion failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Convert JSON schema back to your new XML form definition format
-   */
-  static convertJsonToXml(jsonForm: FormSchemaFieldsOnlyExtended): string {
-    try {
-      const doc = document.implementation.createDocument('', '', null);
-      const xforms = doc.createElement('Xforms');
-
-      Object.entries(( (jsonForm as any).schema ? (jsonForm as any).schema : (jsonForm as any).fields )).forEach(([fieldID, field]) => {
-        const fieldEl = doc.createElement('Fields');
-        const fieldToUse = (field as FormFieldExtended);
-
-        // Set all subelements based on your XML structure
-        // ID, PK IDs etc are missing here, so omit or generate dummy
-
-        // <SystemName>
-        const systemNameEl = doc.createElement('SystemName');
-        systemNameEl.textContent = fieldToUse.SystemName;
-        fieldEl.appendChild(systemNameEl);
-
-        // <LabelText>
-        const labelEl = doc.createElement('LabelText');
-        labelEl.textContent = fieldToUse.title || fieldID;
-        fieldEl.appendChild(labelEl);
-
-        // <HelpText>
-        const helpEl = doc.createElement('HelpText');
-        helpEl.textContent = fieldToUse.description;
-        fieldEl.appendChild(helpEl);
-
-        // <ControlType>
-        const controlTypeEl = doc.createElement('ControlType');
-        controlTypeEl.textContent = fieldToUse.realType;
-        fieldEl.appendChild(controlTypeEl);
-
-        // <ValidationRequired>
-        const validationEl = doc.createElement('ValidationRequired');
-        validationEl.textContent = fieldToUse.required ? 'Required' : 'Not Required';
-        fieldEl.appendChild(validationEl);
-
-        // <DefaultValue>
-        const defaultEl = doc.createElement('DefaultValue');
-        const valueEl = doc.createElement('Value');
-        if (jsonForm[fieldID] !== undefined) {
-          defaultEl.textContent = jsonForm[fieldID].toString();
-          valueEl.textContent = jsonForm[fieldID].toString();
-        }
-        else {
-          defaultEl.textContent = fieldToUse.default || fieldToUse.value;
-          valueEl.textContent = fieldToUse.value || fieldToUse.default;
-        }
-        fieldEl.appendChild(defaultEl);
-        fieldEl.appendChild(valueEl);
-
-        // <Enabled>
-        const enabledEl = doc.createElement('Enabled');
-        enabledEl.textContent = fieldToUse.Enabled === false ? 'False' : 'True';
-        fieldEl.appendChild(enabledEl);
-
-        // Add <isForm> Field to distinguish Field or Header etc
-        const isFormEl = doc.createElement('isForm');
-        isFormEl.textContent = fieldToUse.isForm;
-        fieldEl.appendChild(isFormEl);
-
-        if (fieldToUse.type === 'header') {
-          const headerEl = doc.createElement('Header');
-          headerEl.textContent = fieldToUse.title;
-          fieldEl.appendChild(headerEl);
-        }
-        
-        const idEl = doc.createElement('ID');
-        idEl.textContent = fieldToUse.ID;
-        fieldEl.appendChild(idEl);
-
-        const tfiePkIdEl = doc.createElement('TFie_PK_ID');
-        tfiePkIdEl.textContent = fieldToUse.TFie_PK_ID;
-        fieldEl.appendChild(tfiePkIdEl);
-
-        const tvalPkIdEl = doc.createElement('TVal_PK_ID');
-        tvalPkIdEl.textContent = fieldToUse.TVal_PK_ID;
-        fieldEl.appendChild(tvalPkIdEl);
-
-        const tfInPkIdEl = doc.createElement('TFIn_PK_ID');
-        tfInPkIdEl.textContent = fieldToUse.TFIn_PK_ID;
-        fieldEl.appendChild(tfInPkIdEl);
-
-        const cssStyleEl = doc.createElement('CssStyle');
-        cssStyleEl.textContent = fieldToUse.CssStyle;
-        fieldEl.appendChild(cssStyleEl);
-
-        const typeIdEl = doc.createElement('TypeId');
-        typeIdEl.textContent = fieldToUse.TypeId;
-        fieldEl.appendChild(typeIdEl);
-
-        const unitEl = doc.createElement('Unit');
-        unitEl.textContent = fieldToUse.Unit;
-        fieldEl.appendChild(unitEl);
-
-        const tfieFullPathEl = doc.createElement('TFie_Fullpath');
-        tfieFullPathEl.textContent = fieldToUse.TFie_Fullpath;
-        fieldEl.appendChild(tfieFullPathEl);
-
-        const tvalFkParentIdEl = doc.createElement('TVal_FK_Parent_ID');
-        tvalFkParentIdEl.textContent = fieldToUse.TVal_FK_Parent_ID;
-        fieldEl.appendChild(tvalFkParentIdEl);
-
-        const validationMinEl = doc.createElement('ValidationMin');
-        validationMinEl.textContent = fieldToUse.ValidationMin;
-        fieldEl.appendChild(validationMinEl);
-
-        const validationMaxEl = doc.createElement('ValidationMax');
-        validationMaxEl.textContent = fieldToUse.ValidationMax;
-        fieldEl.appendChild(validationMaxEl);
-
-        const maskEl = doc.createElement('Mask');
-        maskEl.textContent = fieldToUse.Mask;
-        fieldEl.appendChild(maskEl);
-
-        // Append to Xforms root
-        xforms.appendChild(fieldEl);
-      });
-
-      doc.appendChild(xforms);
-
-      const serializer = new XMLSerializer();
-      return serializer.serializeToString(doc);
-    } catch (error) {
-      throw new Error(`JSON to XML conversion failed: ${error.message}`);
-    }
-  }
-
-  private static mapControlTypeToJsonType(controlType: string): FormField['type'] {
-    // Map your ControlType XML field to JSON field types
-    switch (controlType.toLowerCase()) {
-      case 'textbox':
-      case 'text':
-        return 'string';
-      case 'datepicker':
-        return 'date';
-      case 'thesauruspicker':
-      case 'thesauruspicker-ddl':
-      case 'termpicker':
-        return 'select';
-      case 'dbpicker':
-        return 'dbpicker'; // custom type if needed
-      case 'header':
-        return 'header'; // special type to handle header elements
-      case 'checkbox':
-        return 'boolean';
-      case 'realpicker':
-        return 'number';
-      default:
-        return 'string';
-    }
-  }
-
-  // private static mapJsonTypeToControlType(type: string): string {
-  //   switch (type.toLowerCase()) {
-  //     case 'string':
-  //       return 'TextBox';
-  //     case 'date':
-  //       return 'DatePicker';
-  //     case 'select':
-  //       return 'ThesaurusPicker';
-  //     case 'dbpicker':
-  //       return 'DBPicker';
-  //     case 'boolean':
-  //       return 'CheckBox';
-  //     case 'header':
-  //       return 'Header';
-  //     default:
-  //       return 'TextBox';
-  //   }
-  // }
-
-}

package/stencil.config.ts

@@ -1,24 +0,0 @@
-import { Config } from '@stencil/core';
-
-export const config: Config = {
-  namespace: 'voice-input-module',
-  outputTargets: [
-    {
-      type: 'dist',
-      esmLoaderPath: '../loader',
-    },
-    {
-      type: 'dist-custom-elements',
-    },
-    {
-      type: 'docs-readme',
-    },
-    {
-      type: 'www',
-      serviceWorker: null,
-    },
-  ],
-  testing: {
-    browserHeadless: "shell",
-  },
-};

package/tsconfig.json

@@ -1,30 +0,0 @@
-{
-  "compilerOptions": {
-    "allowSyntheticDefaultImports": true,
-    "allowUnreachableCode": false,
-    "declaration": false,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "lib": [
-      "dom",
-      "es6",
-      "es2017"
-    ],
-    "moduleResolution": "node",
-    "module": "esnext",
-    "target": "es2017",
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "jsx": "react",
-    "jsxFactory": "h",
-    "strict": false,
-    "noImplicitAny": false
-  },
-  "include": [
-    "src",
-    "types/jsx.d.ts"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
-}