import { TYPES } from 'loopar';

console.log(TYPES.string);    // 'STRING'
console.log(TYPES.integer);   // 'INTEGER'
console.log(TYPES.date);      // 'DATEONLY'
console.log(TYPES.dateTime);  // 'DATE'

import { inputType } from 'loopar';

console.log(inputType.email);    // 'email'
console.log(inputType.decimal);  // 'number'

import { ELEMENT_GROUPS } from 'loopar';

console.log(ELEMENT_GROUPS.LAYOUT_ELEMENT);  // 'layout'
console.log(ELEMENT_GROUPS.DESIGN_ELEMENT);  // 'design'
console.log(ELEMENT_GROUPS.FORM_ELEMENT);    // 'form'
console.log(ELEMENT_GROUPS.HTML_ELEMENT);    // 'html'

import { elementsDefinition, ELEMENT_GROUPS } from 'loopar';

// Access layout elements
const layoutElements = elementsDefinition[ELEMENT_GROUPS.LAYOUT_ELEMENT];
// Returns array of layout element definitions

// Access form elements
const formElements = elementsDefinition[ELEMENT_GROUPS.FORM_ELEMENT];
// Returns array of form element definitions

import { elementsDict } from 'loopar';

// Get element definition
const inputDef = elementsDict['input'];
console.log(inputDef);
// Output: {
//   def: {
//     element: 'input',
//     icon: 'FormInput',
//     type: 'STRING',
//     group: 'form',
//     isWritable: true
//   }
// }

// Check if element is writable (stores data)
const isWritable = elementsDict['input'].def.isWritable;
// Output: true (form elements are writable)

const notWritable = elementsDict['button'].def.isWritable;
// Output: false (design elements are not writable)

import { elementsNames } from 'loopar';

console.log(elementsNames);
// Output: ['section', 'div', 'row', 'col', ...]

// Check if element exists
if (elementsNames.includes('input')) {
  console.log('Input element is available');
}

// Filter elements
const layoutElements = elementsNames.filter(name => 
  elementsDict[name].def.group === 'layout'
);

import { elementsNameByType, TYPES } from 'loopar';

// Get all string-type elements
const stringElements = elementsNameByType(TYPES.string);
// Output: ['input', 'select', 'form_table']

// Get all date-related elements
const dateElements = elementsNameByType(TYPES.date);
// Output: ['date']

// Get all integer elements
const integerElements = elementsNameByType(TYPES.integer);
// Output: ['integer', 'checkbox', 'switch', 'radio_item']

import { dataInterface } from 'loopar';

const element = {
  element: 'input',
  data: {
    label: 'Email',
    name: 'email',
    format: 'email',
    required: true
  }
};

const validator = dataInterface(element, '[email protected]');

// Validate the value
const result = validator.validate();
console.log(result);
// Output: { valid: true, message: '' }

// Invalid email
const invalidValidator = dataInterface(element, 'invalid-email');
const invalidResult = invalidValidator.validate();
// Output: { valid: false, message: "'invalid-email' is not a valid value in Email" }

import { dataInterface } from 'loopar';

const formFields = [
  {
    element: 'input',
    data: { label: 'Name', name: 'name', required: true }
  },
  {
    element: 'input',
    data: { label: 'Email', name: 'email', format: 'email', required: true }
  },
  {
    element: 'date',
    data: { label: 'Birth Date', name: 'birthDate', required: true }
  }
];

const formData = {
  name: '',
  email: 'invalid',
  birthDate: '2024-03-15'
};

const errors = [];

formFields.forEach(field => {
  const validator = dataInterface(field, formData[field.data.name]);
  const result = validator.validate();
  
  if (!result.valid) {
    errors.push({
      field: field.data.name,
      message: result.message
    });
  }
});

console.log(errors);
// Output:
// [
//   { field: 'name', message: 'Name is required' },
//   { field: 'email', message: "'invalid' is not a valid value in Email" }
// ]

// Available globally
const def = ELEMENT_DEFINITION('input');
console.log(def);
// Output: { element: 'input', icon: 'FormInput', type: 'STRING', ... }

// With fallback
const defWithFallback = ELEMENT_DEFINITION('nonexistent', 'input');
// Returns 'input' definition if 'nonexistent' not found

// Error if not found
const error = ELEMENT_DEFINITION('nonexistent');
// Throws: Error('Element nonexistent not found')

// Available globally
const isWritable = fieldIsWritable({ element: 'input' });
console.log(isWritable); // true (form elements are writable)

const notWritable = fieldIsWritable({ element: 'button' });
console.log(notWritable); // false (design elements are not writable)

import { AIPrompt } from 'loopar';

const { system, user } = AIPrompt(
  'Create a user registration form with name, email, password',
  'Entity'
);

// Use with AI API
const response = await ai.generate({
  systemMessage: system.content,
  userMessage: user.content
});

import { GlobalEnvironment } from 'loopar';

// Initialize global error constants
GlobalEnvironment();

// Use global constants
throw VALIDATION_ERROR;           // { code: 400, title: 'Validation error' }
throw NOT_FOUND_ERROR;            // { code: 404, title: 'Not found' }
throw UNAUTHORIZED_ERROR;         // { code: 401, title: 'Unauthorized' }
throw INTERNAL_SERVER_ERROR;      // { code: 500, title: 'Internal server error' }

import {
  // Type Constants
  TYPES,
  inputType,
  ELEMENT_GROUPS,
  
  // Element Definitions
  elementsDefinition,
  elementsDict,
  elementsNames,
  elementsNameByType,
  
  // Validation
  dataInterface,
  
  // AI Integration
  AIPrompt,
  
  // Environment Setup
  GlobalEnvironment
} from 'loopar';