@omega.js/client 0.1.0

package/dist/modules/bindings.js

@@ -0,0 +1,319 @@
+import { createLogger } from './logger.js';
+
+const logger = createLogger('bindings');
+
+class Bindings {
+  constructor(manager) {
+    this.manager = manager;
+    this._context = {};
+  }
+
+  // Update bindings with new data
+  update(data = {}) {
+    // Merge new data with existing context
+    // Whatever keys are provided will overwrite existing values
+    this._context = {
+      ...this._context,
+      ...data
+    };
+
+    // Get the top-level keys that were updating
+    const updatedKeys = Object.keys(data);
+
+    this._updateBindings(this._context, updatedKeys);
+  }
+
+  // Get current context
+  getContext() {
+    return this._context;
+  }
+
+  // Clear all context
+  clear() {
+    this._context = {};
+    this._updateBindings(this._context, null); // null = update all bindings
+  }
+
+  // Main binding update system
+  _updateBindings(context, updatedKeys = null) {
+    // Find all elements with data-omega-bind attribute
+    const bindElements = document.querySelectorAll('[data-omega-bind]');
+
+    /* @dev-only:start */
+    {
+      logger.log('Updating bindings', context, updatedKeys);
+    }
+    /* @dev-only:end */
+
+    bindElements.forEach(element => {
+      const bindValue = element.getAttribute('data-omega-bind');
+
+      // Split by comma to support multiple actions
+      const bindings = this._parseBindings(bindValue);
+
+      // Execute each action, track if any were actually processed
+      let anyProcessed = false;
+      bindings.forEach(({ action, expression }) => {
+        if (this._executeAction(element, action, expression, context, updatedKeys)) {
+          anyProcessed = true;
+        }
+      });
+
+      // Only remove skeleton if at least one binding was actually processed
+      if (!anyProcessed) return;
+
+      // Add bound class to trigger fade out
+      element.classList.add('omega-bound');
+
+      // Remove skeleton class after fade completes
+      setTimeout(() => {
+        element.classList.remove('omega-binding-skeleton');
+      }, 300);
+    });
+  }
+
+  // Parse binding string into separate actions
+  _parseBindings(bindValue) {
+    const bindings = [];
+
+    // Split by comma, but be smart about it
+    // We need to handle cases where commas might be inside expressions
+    const parts = bindValue.split(',').map(p => p.trim());
+
+    parts.forEach(part => {
+      let action = '@text'; // Default action
+      let expression = part;
+
+      // Check if it starts with an action keyword
+      if (part.startsWith('@')) {
+        const spaceIndex = part.indexOf(' ');
+        if (spaceIndex > -1) {
+          action = part.slice(0, spaceIndex);
+          expression = part.slice(spaceIndex + 1).trim();
+        } else {
+          // No space means it's just an action with no expression (like @hide)
+          action = part;
+          expression = '';
+        }
+      }
+
+      bindings.push({ action, expression });
+    });
+
+    return bindings;
+  }
+
+  // Execute a single action on an element
+  // Returns true if the action was processed, false if skipped
+  _executeAction(element, action, expression, context, updatedKeys = null) {
+    switch (action) {
+      case '@show':
+        // Show element if condition is true (or always if no condition)
+
+        // Check if this path should be updated
+        if (!this._shouldUpdatePath(expression, updatedKeys)) {
+          return false;
+        }
+
+        const shouldShow = expression ? this._evaluateCondition(expression, context) : true;
+        if (shouldShow) {
+          element.removeAttribute('hidden');
+        } else {
+          element.setAttribute('hidden', '');
+        }
+        return true;
+
+      case '@hide':
+        // Hide element if condition is true (or always if no condition)
+
+        // Check if this path should be updated
+        if (!this._shouldUpdatePath(expression, updatedKeys)) {
+          return false;
+        }
+
+        const shouldHide = expression ? this._evaluateCondition(expression, context) : true;
+        if (shouldHide) {
+          element.setAttribute('hidden', '');
+        } else {
+          element.removeAttribute('hidden');
+        }
+        return true;
+
+      case '@attr':
+        // Set attribute value
+        // Format: @attr attributeName expression
+        const attrParts = expression.split(' ');
+        const attrName = attrParts[0];
+        const attrExpression = attrParts.slice(1).join(' ');
+
+        // Check if this path should be updated
+        if (!this._shouldUpdatePath(attrExpression, updatedKeys)) {
+          return false;
+        }
+
+        const attrValue = this._resolvePath(context, attrExpression) || '';
+
+        if (attrValue) {
+          // Block javascript: protocol on URL attributes to prevent XSS
+          const URL_ATTRS = ['href', 'src', 'action', 'formaction'];
+          if (URL_ATTRS.includes(attrName.toLowerCase())
+            && /^\s*javascript\s*:/i.test(String(attrValue))) {
+            logger.warn(`Blocked javascript: URL in @attr ${attrName}`);
+            return true;
+          }
+
+          element.setAttribute(attrName, attrValue);
+        } else {
+          element.removeAttribute(attrName);
+        }
+        return true;
+
+      case '@style':
+        // Set CSS custom property or style
+        // Format: @style propertyName expression
+        const styleParts = expression.split(' ');
+        const styleName = styleParts[0];
+        const styleExpression = styleParts.slice(1).join(' ');
+
+        // Check if this path should be updated
+        if (!this._shouldUpdatePath(styleExpression, updatedKeys)) {
+          return false;
+        }
+
+        const styleValue = this._resolvePath(context, styleExpression);
+
+        if (styleValue !== null && styleValue !== undefined && styleValue !== '') {
+          // If it starts with --, it's a CSS custom property
+          if (styleName.startsWith('--')) {
+            element.style.setProperty(styleName, styleValue);
+          } else {
+            // Regular style property
+            element.style[styleName] = styleValue;
+          }
+        } else {
+          // Remove the style if value is empty
+          if (styleName.startsWith('--')) {
+            element.style.removeProperty(styleName);
+          } else {
+            element.style[styleName] = '';
+          }
+        }
+        return true;
+
+      case '@value':
+        // Set input/textarea value explicitly
+        // Check if this path should be updated
+        if (!this._shouldUpdatePath(expression, updatedKeys)) {
+          return false;
+        }
+
+        const inputValue = this._resolvePath(context, expression) ?? '';
+        element.value = inputValue;
+        return true;
+
+      case '@text':
+      default:
+        // Set text content (default behavior)
+
+        // Check if this path should be updated
+        if (!this._shouldUpdatePath(expression, updatedKeys)) {
+          return false;
+        }
+
+        const textValue = this._resolvePath(context, expression) ?? '';
+        element.textContent = textValue;
+        return true;
+    }
+  }
+
+  // Check if a path should be updated based on updatedKeys
+  _shouldUpdatePath(path, updatedKeys) {
+    // If no updatedKeys filter, always update
+    if (updatedKeys === null || !path) {
+      return true;
+    }
+
+    // Strip negation operator if present before extracting root key
+    const cleanPath = path.trim().replace(/^!/, '');
+
+    // Extract the root key from the path
+    const rootKey = cleanPath.split('.')[0];
+
+    // Only update if the root key is in updatedKeys
+    return updatedKeys.includes(rootKey);
+  }
+
+  // Resolve nested object path
+  _resolvePath(obj, path) {
+    if (!obj || !path) return null;
+
+    return path.split('.').reduce((current, key) => {
+      return current?.[key];
+    }, obj);
+  }
+
+  // Safely evaluate simple conditions
+  _evaluateCondition(condition, context) {
+    try {
+      // Replace context references with actual values
+      // Support: auth.user.field, auth.account.field, simple comparisons
+
+      // Check for negation operator at the start
+      if (condition.trim().startsWith('!')) {
+        const expression = condition.trim().slice(1).trim();
+        const value = this._resolvePath(context, expression);
+        return !value;
+      }
+
+      // Parse the condition to extract left side, operator, and right side
+      // Longest alternatives first — `>` before `>=` would shadow `>=` forever
+      const comparisonMatch = condition.match(/^(.+?)\s*(===|!==|==|!=|>=|<=|>|<)\s*(.+)$/);
+
+      if (comparisonMatch) {
+        const [, leftPath, operator, rightValue] = comparisonMatch;
+
+        // Get the left side value
+        const leftValue = this._resolvePath(context, leftPath.trim());
+
+        // Parse the right side (could be string, number, boolean)
+        let right = rightValue.trim();
+
+        // Remove quotes if it's a string
+        if ((right.startsWith("'") && right.endsWith("'")) ||
+            (right.startsWith('"') && right.endsWith('"'))) {
+          right = right.slice(1, -1);
+        } else if (right === 'true') {
+          right = true;
+        } else if (right === 'false') {
+          right = false;
+        } else if (right === 'null') {
+          right = null;
+        } else if (!isNaN(right)) {
+          right = Number(right);
+        }
+
+        // Evaluate based on operator
+        switch (operator) {
+          case '===': return leftValue === right;
+          case '!==': return leftValue !== right;
+          case '==': return leftValue == right;
+          case '!=': return leftValue != right;
+          case '>': return leftValue > right;
+          case '<': return leftValue < right;
+          case '>=': return leftValue >= right;
+          case '<=': return leftValue <= right;
+          default: return false;
+        }
+      } else {
+        // Simple truthy check (e.g., "auth.user.emailVerified" or "auth.account")
+        const value = this._resolvePath(context, condition.trim());
+        return !!value;
+      }
+    } catch (error) {
+      console.warn('Failed to evaluate condition:', condition, error);
+      return false;
+    }
+  }
+}
+
+export default Bindings;

package/dist/modules/device.js

@@ -0,0 +1,282 @@
+import { createLogger } from './logger.js';
+
+const logger = createLogger('device');
+
+// Unit multipliers
+const UNITS = {
+  milliseconds: 1,
+  seconds: 1000,
+  minutes: 1000 * 60,
+  hours: 1000 * 60 * 60,
+  days: 1000 * 60 * 60 * 24,
+};
+
+// Storage key 
+const STORAGE_KEY = 'omega_device';
+
+// Session timeout (30 minutes of inactivity = new session)
+const SESSION_TIMEOUT = 30 * 60 * 1000;
+
+class Device {
+  constructor(manager) {
+    this.manager = manager;
+    this.data = null;
+    this.initialized = false;
+    this.isNewVersion = false;
+  }
+
+  // Check if we're in a browser extension context
+  _isExtension() {
+    return this.manager.utilities().getRuntime() === 'browser-extension';
+  }
+
+  // Get extension storage API
+  _getExtensionStorage() {
+    if (typeof chrome !== 'undefined' && chrome.storage?.local) {
+      return chrome.storage.local;
+    }
+    if (typeof browser !== 'undefined' && browser.storage?.local) {
+      return browser.storage.local;
+    }
+    return null;
+  }
+
+  // Initialize - loads or creates usage data (async for extensions)
+  async initialize() {
+    // Skip if already initialized
+    if (this.initialized) {
+      return this.data;
+    }
+
+    // Load existing data based on runtime
+    let existing = null;
+
+    if (this._isExtension()) {
+      existing = await this._loadFromExtensionStorage();
+    } else {
+      existing = this._loadFromLocalStorage();
+    }
+
+    const now = Date.now();
+    const currentVersion = this.manager.config?.version || null;
+
+    // Stored data is raw JSON.parse output — only a plain object is usable;
+    // a primitive or array entry falls through to the first-time payload
+    if (existing && typeof existing !== 'object') {
+      existing = null;
+    }
+    if (Array.isArray(existing)) {
+      existing = null;
+    }
+
+    if (existing) {
+      this.data = existing;
+
+      // Check if this is a new session (last activity was more than SESSION_TIMEOUT ago)
+      const timeSinceLastActive = now - (this.data.lastActive || 0);
+      if (timeSinceLastActive > SESSION_TIMEOUT) {
+        // A malformed entry missing `session` (or carrying a non-object
+        // there) must not break the whole manager boot
+        if (!this.data.session || typeof this.data.session !== 'object') {
+          this.data.session = {};
+        }
+        this.data.session.count = (this.data.session.count || 0) + 1;
+        this.data.session.started = now;
+      }
+
+      // Update lastActive
+      this.data.lastActive = now;
+
+      // Check for version change
+      if (currentVersion && this.data.version?.current !== currentVersion) {
+        this.data.version = this.data.version || {};
+        this.data.version.previous = this.data.version.current;
+        this.data.version.current = currentVersion;
+        this.isNewVersion = true;
+      }
+
+      await this._save();
+    } else {
+      // First time usage
+      this.data = {
+        installed: now,
+        lastActive: now,
+        session: {
+          started: now,
+          count: 1,
+        },
+        version: {
+          initial: currentVersion,
+          current: currentVersion,
+          previous: null,
+        },
+      };
+      await this._save();
+    }
+
+    this.initialized = true;
+    return this.data;
+  }
+
+  // Load from extension storage (async)
+  async _loadFromExtensionStorage() {
+    const storage = this._getExtensionStorage();
+    if (!storage) {
+      return null;
+    }
+
+    try {
+      const result = await storage.get(STORAGE_KEY);
+      return result[STORAGE_KEY] || null;
+    } catch (e) {
+      logger.warn('Failed to load from extension storage:', e);
+      return null;
+    }
+  }
+
+  // Load from localStorage (sync)
+  _loadFromLocalStorage() {
+    try {
+      const data = localStorage.getItem(STORAGE_KEY);
+      return data ? JSON.parse(data) : null;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  // Save data to storage
+  async _save() {
+    if (this._isExtension()) {
+      await this._saveToExtensionStorage();
+    } else {
+      this._saveToLocalStorage();
+    }
+
+    return this.data;
+  }
+
+  // Save to extension storage (async)
+  async _saveToExtensionStorage() {
+    const storage = this._getExtensionStorage();
+    if (!storage) {
+      return;
+    }
+
+    try {
+      await storage.set({ [STORAGE_KEY]: this.data });
+    } catch (e) {
+      logger.warn('Failed to save to extension storage:', e);
+    }
+  }
+
+  // Save to localStorage (sync)
+  _saveToLocalStorage() {
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(this.data));
+    } catch (e) {
+      // localStorage not available
+    }
+  }
+
+  // Calculate duration from a timestamp in specified units
+  _calculateDuration(timestamp, unit) {
+    if (!timestamp) {
+      return 0;
+    }
+
+    // Default to milliseconds
+    unit = unit || 'milliseconds';
+
+    // Get multiplier
+    const multiplier = UNITS[unit];
+    if (!multiplier) {
+      throw new Error(`Invalid unit: ${unit}. Valid units: ${Object.keys(UNITS).join(', ')}`);
+    }
+
+    return (Date.now() - timestamp) / multiplier;
+  }
+
+  // Get total usage duration in specified units (since installed)
+  getUsageDuration(unit) {
+    return this._calculateDuration(this.data?.installed, unit);
+  }
+
+  // Get current session duration in specified units
+  getSessionDuration(unit) {
+    return this._calculateDuration(this.data?.session?.started, unit);
+  }
+
+  // Get installed date
+  getInstalledDate() {
+    if (!this.data?.installed) {
+      return null;
+    }
+
+    return new Date(this.data.installed);
+  }
+
+  // Get session count
+  getSessionCount() {
+    return this.data?.session?.count || 0;
+  }
+
+  // Reset usage data (for testing or user request)
+  async reset() {
+    const now = Date.now();
+    const currentVersion = this.manager.config?.version || null;
+
+    this.data = {
+      installed: now,
+      lastActive: now,
+      session: {
+        started: now,
+        count: 1,
+      },
+      version: {
+        initial: currentVersion,
+        current: currentVersion,
+        previous: null,
+      },
+    };
+
+    this.isNewVersion = false;
+    await this._save();
+    return this.data;
+  }
+
+  // Get binding-friendly data object for bindings system
+  getBindingData() {
+    return {
+      installed: this.data?.installed || null,
+      lastActive: this.data?.lastActive || null,
+      session: {
+        started: this.data?.session?.started || null,
+        count: this.getSessionCount(),
+      },
+      version: {
+        initial: this.data?.version?.initial || null,
+        current: this.data?.version?.current || null,
+        previous: this.data?.version?.previous || null,
+        isNew: this.isNewVersion,
+      },
+      duration: {
+        total: {
+          milliseconds: this.getUsageDuration('milliseconds'),
+          seconds: this.getUsageDuration('seconds'),
+          minutes: this.getUsageDuration('minutes'),
+          hours: this.getUsageDuration('hours'),
+          days: this.getUsageDuration('days'),
+        },
+        session: {
+          milliseconds: this.getSessionDuration('milliseconds'),
+          seconds: this.getSessionDuration('seconds'),
+          minutes: this.getSessionDuration('minutes'),
+          hours: this.getSessionDuration('hours'),
+          days: this.getSessionDuration('days'),
+        },
+      },
+    };
+  }
+}
+
+export default Device;

package/dist/modules/dom.js

@@ -0,0 +1,96 @@
+// Load external script dynamically
+export function loadScript(options) {
+  return new Promise((resolve, reject) => {
+    // Handle simple string parameter
+    if (typeof options === 'string') {
+      options = { src: options };
+    }
+
+    const {
+      src,
+      async = true,
+      defer = false,
+      crossorigin = false,
+      integrity = null,
+      attributes = {},
+      timeout = 60000,
+      retries = 0,
+      parent = null
+    } = options;
+
+    if (!src) {
+      return reject(new Error('Script source is required'));
+    }
+
+    let timeoutId;
+    let retryCount = 0;
+
+    function createAndLoadScript() {
+      const script = document.createElement('script');
+      script.src = src;
+      script.async = async;
+      script.defer = defer;
+
+      if (crossorigin) {
+        script.crossOrigin = typeof crossorigin === 'string' ? crossorigin : 'anonymous';
+      }
+
+      if (integrity) {
+        script.integrity = integrity;
+      }
+
+      // Add custom attributes
+      Object.keys(attributes).forEach(name => {
+        script.setAttribute(name, attributes[name]);
+      });
+
+      // Set up timeout
+      if (timeout > 0) {
+        timeoutId = setTimeout(() => {
+          script.remove();
+          handleError(new Error(`Script load timeout: ${src}`));
+        }, timeout);
+      }
+
+      // Event handlers
+      script.onload = () => {
+        clearTimeout(timeoutId);
+        resolve({ script, cached: false });
+      };
+
+      script.onerror = (error) => {
+        clearTimeout(timeoutId);
+        script.remove();
+        handleError(new Error(`Failed to load script ${src}`, { cause: error }));
+      };
+
+      // Append to document
+      const $targetParent = parent || document.head || document.documentElement;
+      $targetParent.appendChild(script);
+    }
+
+    function handleError(error) {
+      if (retryCount < retries) {
+        retryCount++;
+        setTimeout(createAndLoadScript, 1000 * retryCount);
+      } else {
+        reject(error);
+      }
+    }
+
+    createAndLoadScript();
+  });
+}
+
+// Return promise that resolves when DOM is ready
+export function ready() {
+  return new Promise((resolve) => {
+    if (document.readyState === 'loading') {
+      // Wait for DOM if still loading
+      document.addEventListener('DOMContentLoaded', resolve);
+    } else {
+      // DOM is already ready
+      resolve();
+    }
+  });
+}