@kaiserofthenight/human-js 1.0.0

package/src/plugins/http.js

@@ -0,0 +1,167 @@
+/**
+ * HTTP CLIENT PLUGIN
+ * 
+ * Simple fetch wrapper with better ergonomics.
+ * Inspired by Axios but much simpler.
+ */
+
+/**
+ * Create an HTTP client
+ * @param {Object} config - Default configuration
+ */
+export function createHttp(config = {}) {
+  const {
+    baseURL = '',
+    headers = {},
+    timeout = 30000,
+    onRequest = null,
+    onResponse = null,
+    onError = null
+  } = config;
+  
+  /**
+   * Make HTTP request
+   */
+  async function request(url, options = {}) {
+    // Merge headers
+    const requestHeaders = {
+      'Content-Type': 'application/json',
+      ...headers,
+      ...options.headers
+    };
+    
+    // Build full URL
+    const fullUrl = url.startsWith('http') ? url : `${baseURL}${url}`;
+    
+    // Request config
+    const fetchOptions = {
+      method: options.method || 'GET',
+      headers: requestHeaders,
+      ...options
+    };
+    
+    // Add body for non-GET requests
+    if (options.body && typeof options.body === 'object') {
+      fetchOptions.body = JSON.stringify(options.body);
+    }
+    
+    // Call onRequest interceptor
+    if (onRequest) {
+      const modified = onRequest(fetchOptions);
+      if (modified) Object.assign(fetchOptions, modified);
+    }
+    
+    try {
+      // Create abort controller for timeout
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      fetchOptions.signal = controller.signal;
+      
+      // Make request
+      const response = await fetch(fullUrl, fetchOptions);
+      clearTimeout(timeoutId);
+      
+      // Parse response
+      let data;
+      const contentType = response.headers.get('content-type');
+      
+      if (contentType && contentType.includes('application/json')) {
+        data = await response.json();
+      } else {
+        data = await response.text();
+      }
+      
+      // Build response object
+      const result = {
+        data,
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        ok: response.ok
+      };
+      
+      // Call onResponse interceptor
+      if (onResponse) {
+        const modified = onResponse(result);
+        if (modified) return modified;
+      }
+      
+      // Throw on error status
+      if (!response.ok) {
+        throw new HttpError(result.statusText, result);
+      }
+      
+      return result;
+    } catch (error) {
+      // Call onError interceptor
+      if (onError) {
+        onError(error);
+      }
+      
+      throw error;
+    }
+  }
+  
+  // Convenience methods
+  return {
+    request,
+    
+    get(url, options = {}) {
+      return request(url, { ...options, method: 'GET' });
+    },
+    
+    post(url, body, options = {}) {
+      return request(url, { ...options, method: 'POST', body });
+    },
+    
+    put(url, body, options = {}) {
+      return request(url, { ...options, method: 'PUT', body });
+    },
+    
+    patch(url, body, options = {}) {
+      return request(url, { ...options, method: 'PATCH', body });
+    },
+    
+    delete(url, options = {}) {
+      return request(url, { ...options, method: 'DELETE' });
+    }
+  };
+}
+
+/**
+ * Custom HTTP error
+ */
+class HttpError extends Error {
+  constructor(message, response) {
+    super(message);
+    this.name = 'HttpError';
+    this.response = response;
+  }
+}
+
+/**
+ * Default HTTP client instance
+ */
+export const http = createHttp();
+
+/**
+ * Example usage:
+ * 
+ * // Simple request
+ * const { data } = await http.get('/api/users');
+ * 
+ * // With custom client
+ * const api = createHttp({
+ *   baseURL: 'https://api.example.com',
+ *   headers: { 'Authorization': 'Bearer token' },
+ *   onRequest: (config) => {
+ *     console.log('Making request:', config);
+ *   },
+ *   onError: (error) => {
+ *     console.error('Request failed:', error);
+ *   }
+ * });
+ * 
+ * const users = await api.get('/users');
+ * await api.post('/users', { name: 'John' });
+ */

package/src/plugins/storage.js

@@ -0,0 +1,181 @@
+/**
+ * STORAGE PLUGIN
+ * 
+ * Simple wrapper around localStorage and sessionStorage.
+ * Automatically handles JSON serialization.
+ */
+
+/**
+ * Create a storage instance
+ * @param {Storage} storage - localStorage or sessionStorage
+ * @param {String} prefix - Key prefix for namespacing
+ */
+function createStorage(storage, prefix = '') {
+  return {
+    /**
+     * Set item
+     */
+    set(key, value) {
+      try {
+        const fullKey = prefix + key;
+        const serialized = JSON.stringify(value);
+        storage.setItem(fullKey, serialized);
+        return true;
+      } catch (error) {
+        console.error('[Storage] Set failed:', error);
+        return false;
+      }
+    },
+    
+    /**
+     * Get item
+     */
+    get(key, defaultValue = null) {
+      try {
+        const fullKey = prefix + key;
+        const item = storage.getItem(fullKey);
+        
+        if (item === null) return defaultValue;
+        
+        return JSON.parse(item);
+      } catch (error) {
+        console.error('[Storage] Get failed:', error);
+        return defaultValue;
+      }
+    },
+    
+    /**
+     * Remove item
+     */
+    remove(key) {
+      try {
+        const fullKey = prefix + key;
+        storage.removeItem(fullKey);
+        return true;
+      } catch (error) {
+        console.error('[Storage] Remove failed:', error);
+        return false;
+      }
+    },
+    
+    /**
+     * Clear all items (with prefix)
+     */
+    clear() {
+      try {
+        if (prefix) {
+          // Clear only items with prefix
+          const keys = Object.keys(storage);
+          keys.forEach(key => {
+            if (key.startsWith(prefix)) {
+              storage.removeItem(key);
+            }
+          });
+        } else {
+          // Clear everything
+          storage.clear();
+        }
+        return true;
+      } catch (error) {
+        console.error('[Storage] Clear failed:', error);
+        return false;
+      }
+    },
+    
+    /**
+     * Get all keys
+     */
+    keys() {
+      const allKeys = Object.keys(storage);
+      return allKeys
+        .filter(key => !prefix || key.startsWith(prefix))
+        .map(key => prefix ? key.slice(prefix.length) : key);
+    },
+    
+    /**
+     * Check if key exists
+     */
+    has(key) {
+      const fullKey = prefix + key;
+      return storage.getItem(fullKey) !== null;
+    },
+    
+    /**
+     * Get multiple items
+     */
+    getMultiple(keys) {
+      return keys.reduce((result, key) => {
+        result[key] = this.get(key);
+        return result;
+      }, {});
+    },
+    
+    /**
+     * Set multiple items
+     */
+    setMultiple(items) {
+      Object.keys(items).forEach(key => {
+        this.set(key, items[key]);
+      });
+    }
+  };
+}
+
+/**
+ * Local storage (persists across sessions)
+ */
+export const local = createStorage(localStorage);
+
+/**
+ * Session storage (cleared when browser closes)
+ */
+export const session = createStorage(sessionStorage);
+
+/**
+ * Create namespaced storage
+ */
+export function createNamespace(namespace) {
+  return {
+    local: createStorage(localStorage, `${namespace}:`),
+    session: createStorage(sessionStorage, `${namespace}:`)
+  };
+}
+
+/**
+ * Storage events - listen for changes
+ */
+export function onStorageChange(callback) {
+  const handler = (event) => {
+    if (event.storageArea === localStorage) {
+      callback({
+        key: event.key,
+        oldValue: event.oldValue ? JSON.parse(event.oldValue) : null,
+        newValue: event.newValue ? JSON.parse(event.newValue) : null,
+        storage: 'local'
+      });
+    }
+  };
+  
+  window.addEventListener('storage', handler);
+  
+  return () => window.removeEventListener('storage', handler);
+}
+
+/**
+ * Example usage:
+ * 
+ * import { local, session } from './storage.js';
+ * 
+ * // Save data
+ * local.set('user', { name: 'John', age: 30 });
+ * 
+ * // Get data
+ * const user = local.get('user');
+ * 
+ * // With default value
+ * const settings = local.get('settings', { theme: 'light' });
+ * 
+ * // Namespaced storage
+ * const appStorage = createNamespace('myapp');
+ * appStorage.local.set('data', { ... });
+ */

package/src/plugins/validator.js

@@ -0,0 +1,193 @@
+/**
+ * FORM VALIDATION PLUGIN
+ * 
+ * Simple, human-readable validation rules for forms.
+ */
+
+/**
+ * Validation rules
+ */
+export const rules = {
+  required: (value) => {
+    if (value === null || value === undefined || value === '') {
+      return 'This field is required';
+    }
+    return true;
+  },
+  
+  email: (value) => {
+    if (!value) return true; // Use with required for mandatory
+    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return regex.test(value) || 'Invalid email address';
+  },
+  
+  minLength: (min) => (value) => {
+    if (!value) return true;
+    return value.length >= min || `Minimum ${min} characters required`;
+  },
+  
+  maxLength: (max) => (value) => {
+    if (!value) return true;
+    return value.length <= max || `Maximum ${max} characters allowed`;
+  },
+  
+  min: (minValue) => (value) => {
+    const num = Number(value);
+    return num >= minValue || `Minimum value is ${minValue}`;
+  },
+  
+  max: (maxValue) => (value) => {
+    const num = Number(value);
+    return num <= maxValue || `Maximum value is ${maxValue}`;
+  },
+  
+  pattern: (regex, message = 'Invalid format') => (value) => {
+    if (!value) return true;
+    return regex.test(value) || message;
+  },
+  
+  url: (value) => {
+    if (!value) return true;
+    try {
+      new URL(value);
+      return true;
+    } catch {
+      return 'Invalid URL';
+    }
+  },
+  
+  number: (value) => {
+    if (!value) return true;
+    return !isNaN(value) || 'Must be a number';
+  },
+  
+  integer: (value) => {
+    if (!value) return true;
+    return Number.isInteger(Number(value)) || 'Must be an integer';
+  },
+  
+  match: (otherField, fieldName) => (value, allValues) => {
+    return value === allValues[otherField] || `Must match ${fieldName}`;
+  },
+  
+  custom: (fn, message) => (value, allValues) => {
+    return fn(value, allValues) || message;
+  }
+};
+
+/**
+ * Create a validator
+ * @param {Object} schema - Validation schema { field: [rules] }
+ */
+export function createValidator(schema) {
+  return {
+    /**
+     * Validate all fields
+     */
+    validate(values) {
+      const errors = {};
+      
+      Object.keys(schema).forEach(field => {
+        const fieldRules = schema[field];
+        const value = values[field];
+        
+        for (const rule of fieldRules) {
+          const result = rule(value, values);
+          if (result !== true) {
+            errors[field] = result;
+            break; // Stop at first error
+          }
+        }
+      });
+      
+      return {
+        isValid: Object.keys(errors).length === 0,
+        errors
+      };
+    },
+    
+    /**
+     * Validate single field
+     */
+    validateField(field, value, allValues = {}) {
+      const fieldRules = schema[field];
+      if (!fieldRules) return { isValid: true, error: null };
+      
+      for (const rule of fieldRules) {
+        const result = rule(value, allValues);
+        if (result !== true) {
+          return { isValid: false, error: result };
+        }
+      }
+      
+      return { isValid: true, error: null };
+    }
+  };
+}
+
+/**
+ * Form helper - extracts form data
+ */
+export function getFormData(formElement) {
+  const formData = new FormData(formElement);
+  const data = {};
+  
+  for (const [key, value] of formData.entries()) {
+    // Handle multiple checkboxes with same name
+    if (data[key]) {
+      if (Array.isArray(data[key])) {
+        data[key].push(value);
+      } else {
+        data[key] = [data[key], value];
+      }
+    } else {
+      data[key] = value;
+    }
+  }
+  
+  return data;
+}
+
+/**
+ * Display validation errors in form
+ */
+export function displayErrors(formElement, errors) {
+  // Clear previous errors
+  formElement.querySelectorAll('.error-message').forEach(el => el.remove());
+  formElement.querySelectorAll('.error').forEach(el => el.classList.remove('error'));
+  
+  // Display new errors
+  Object.keys(errors).forEach(field => {
+    const input = formElement.querySelector(`[name="${field}"]`);
+    if (!input) return;
+    
+    // Add error class
+    input.classList.add('error');
+    
+    // Create error message
+    const errorDiv = document.createElement('div');
+    errorDiv.className = 'error-message';
+    errorDiv.style.color = 'red';
+    errorDiv.style.fontSize = '14px';
+    errorDiv.style.marginTop = '4px';
+    errorDiv.textContent = errors[field];
+    
+    // Insert after input
+    input.parentNode.insertBefore(errorDiv, input.nextSibling);
+  });
+}
+
+/**
+ * Example usage:
+ * 
+ * const validator = createValidator({
+ *   email: [rules.required, rules.email],
+ *   password: [rules.required, rules.minLength(8)],
+ *   age: [rules.required, rules.number, rules.min(18)]
+ * });
+ * 
+ * const result = validator.validate(formData);
+ * if (!result.isValid) {
+ *   displayErrors(formElement, result.errors);
+ * }
+ */