cr-static-shared-components 9.9.0

package/src/network.js

@@ -0,0 +1,216 @@
+'use strict';
+
+/**
+ * Network & HTTP Utilities Module
+ * HTTP client helpers, retry logic, and network utilities
+ *
+ * @module network
+ */
+
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+
+/**
+ * Make HTTP/HTTPS request with automatic protocol detection
+ */
+function request(url, options = {}) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const client = parsedUrl.protocol === 'https:' ? https : http;
+
+    const req = client.request(url, options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        resolve({
+          statusCode: res.statusCode,
+          headers: res.headers,
+          body: data
+        });
+      });
+    });
+
+    req.on('error', reject);
+
+    if (options.body) {
+      req.write(options.body);
+    }
+
+    req.end();
+  });
+}
+
+/**
+ * GET request
+ */
+function get(url, options = {}) {
+  return request(url, { ...options, method: 'GET' });
+}
+
+/**
+ * POST request
+ */
+function post(url, body, options = {}) {
+  return request(url,{
+    ...options,
+    method: 'POST',
+    body: typeof body === 'string' ? body : JSON.stringify(body)
+  });
+}
+
+/**
+ * Retry a function with exponential backoff
+ */
+async function retry(fn, options = {}) {
+  const {
+    retries = 3,
+    delay = 1000,
+    factor = 2,
+    maxDelay = 30000
+  } = options;
+
+  let lastError;
+  let currentDelay = delay;
+
+  for (let i = 0; i <= retries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+
+      if (i < retries) {
+        await sleep(currentDelay);
+        currentDelay = Math.min(currentDelay * factor, maxDelay);
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Sleep helper
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Parse query string
+ */
+function parseQueryString(query) {
+  return query
+    .replace(/^\?/, '')
+    .split('&')
+    .filter(Boolean)
+    .reduce((acc, pair) => {
+      const [key, value] = pair.split('=');
+      acc[decodeURIComponent(key)] = decodeURIComponent(value || '');
+      return acc;
+    }, {});
+}
+
+/**
+ * Build query string
+ */
+function buildQueryString(params) {
+  return Object.entries(params)
+    .filter(([, value]) => value != null)
+    .map(([key, value]) =>
+      `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+    )
+    .join('&');
+}
+
+/**
+ * Parse URL with validation
+ */
+function parseURL(urlString) {
+  try {
+    const url = new URL(urlString);
+    return {
+      protocol: url.protocol,
+      hostname: url.hostname,
+      port: url.port,
+      pathname: url.pathname,
+      search: url.search,
+      hash: url.hash,
+      query: parseQueryString(url.search)
+    };
+  } catch (error) {
+    throw new Error(`Invalid URL: ${urlString}`);
+  }
+}
+
+/**
+ * Check if URL is absolute
+ */
+function isAbsoluteURL(url) {
+  return /^https?:\/\//i.test(url);
+}
+
+/**
+ * Join URL paths
+ */
+function joinURL(base, ...paths) {
+  const url = base.replace(/\/+$/, '');
+  const path = paths
+    .map(p => p.replace(/^\/+|\/+$/g, ''))
+    .filter(Boolean)
+    .join('/');
+  return path ? `${url}/${path}` : url;
+}
+
+/**
+ * Timeout wrapper for promises
+ */
+function timeout(promise, ms) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) =>
+      setTimeout(() => reject(new Error('Timeout')), ms)
+    )
+  ]);
+}
+
+/**
+ * Parallel request limiter
+ */
+async function parallel(urls, options = {}) {
+  const { concurrency = 5 } = options;
+  const results = [];
+  const queue = [...urls];
+
+  async function worker() {
+    while (queue.length > 0) {
+      const url = queue.shift();
+      try {
+        const result = await get(url, options);
+        results.push({ url, success: true, data: result });
+      } catch (error) {
+        results.push({ url, success: false, error: error.message });
+      }
+    }
+  }
+
+  const workers = Array(concurrency).fill(null).map(() => worker());
+  await Promise.all(workers);
+
+  return results;
+}
+
+module.exports = {
+  request,
+  get,
+  post,
+  retry,
+  sleep,
+  parseQueryString,
+  buildQueryString,
+  parseURL,
+  isAbsoluteURL,
+  joinURL,
+  timeout,
+  parallel
+};

package/src/transformation.js

@@ -0,0 +1,273 @@
+'use strict';
+
+/**
+ * Transformation Module
+ * Provides functional programming utilities for data transformation
+ *
+ * @module transformation
+ */
+
+/**
+ * Compose functions into a pipeline
+ */
+function pipe(...fns) {
+  return (value) => {
+    return fns.reduce((acc, fn) => fn(acc), value);
+  };
+}
+
+/**
+ * Map transformation
+ */
+function map(fn) {
+  return (array) => {
+    if (!Array.isArray(array)) {
+      throw new Error('map() requires an array');
+    }
+    return array.map(fn);
+  };
+}
+
+/**
+ * Filter transformation
+ */
+function filter(predicate) {
+  return (array) => {
+    if (!Array.isArray(array)) {
+      throw new Error('filter() requires an array');
+    }
+    return array.filter(predicate);
+  };
+}
+
+/**
+ * Reduce transformation
+ */
+function reduce(fn, initial) {
+  return (array) => {
+    if (!Array.isArray(array)) {
+      throw new Error('reduce() requires an array');
+    }
+    return array.reduce(fn, initial);
+  };
+}
+
+/**
+ * Sort transformation
+ */
+function sort(compareFn = null) {
+  return (array) => {
+    if (!Array.isArray(array)) {
+      throw new Error('sort() requires an array');
+    }
+    const copy = [...array];
+    return compareFn ? copy.sort(compareFn) : copy.sort();
+  };
+}
+
+/**
+ * Unique/distinct values
+ */
+function unique() {
+  return (array) => {
+    if (!Array.isArray(array)) {
+      throw new Error('unique() requires an array');
+    }
+    return [...new Set(array)];
+  };
+}
+
+/**
+ * Chunk array into smaller arrays
+ */
+function chunk(size) {
+  return (array) => {
+    if (!Array.isArray(array)) {
+      throw new Error('chunk() requires an array');
+    }
+
+    const result = [];
+    for (let i = 0; i < array.length; i += size) {
+      result.push(array.slice(i, i + size));
+    }
+    return result;
+  };
+}
+
+/**
+ * Flatten nested arrays
+ */
+function flatten(depth = Infinity) {
+  return (array) => {
+    if (!Array.isArray(array)) {
+      throw new Error('flatten() requires an array');
+    }
+    return array.flat(depth);
+  };
+}
+
+/**
+ * Group by key
+ */
+function groupBy(keyFn) {
+  return (array) => {
+    if (!Array.isArray(array)) {
+      throw new Error('groupBy() requires an array');
+    }
+
+    return array.reduce((acc, item) => {
+      const key = keyFn(item);
+      if (!acc[key]) {
+        acc[key] = [];
+      }
+      acc[key].push(item);
+      return acc;
+    }, {});
+  };
+}
+
+/**
+ * Partition array based on predicate
+ */
+function partition(predicate) {
+  return (array) => {
+    if (!Array.isArray(array)) {
+      throw new Error('partition() requires an array');
+    }
+
+    return array.reduce((acc, item) => {
+      acc[predicate(item) ? 0 : 1].push(item);
+      return acc;
+    }, [[], []]);
+  };
+}
+
+/**
+ * Take first N elements
+ */
+function take(n) {
+  return (array) => {
+    if (!Array.isArray(array)) {
+      throw new Error('take() requires an array');
+    }
+    return array.slice(0, n);
+  };
+}
+
+/**
+ * Drop first N elements
+ */
+function drop(n) {
+  return (array) => {
+    if (!Array.isArray(array)) {
+      throw new Error('drop() requires an array');
+    }
+    return array.slice(n);
+  };
+}
+
+/**
+ * Zip multiple arrays
+ */
+function zip(...arrays) {
+  const maxLength = Math.max(...arrays.map(arr => arr.length));
+  const result = [];
+
+  for (let i = 0; i < maxLength; i++) {
+    result.push(arrays.map(arr => arr[i]));
+  }
+
+  return result;
+}
+
+/**
+ * Object transformation: pick keys
+ */
+function pick(keys) {
+  return (obj) => {
+    if (typeof obj !== 'object' || obj === null) {
+      throw new Error('pick() requires an object');
+    }
+
+    return keys.reduce((acc, key) => {
+      if (key in obj) {
+        acc[key] = obj[key];
+      }
+      return acc;
+    }, {});
+  };
+}
+
+/**
+ * Object transformation: omit keys
+ */
+function omit(keys) {
+  return (obj) => {
+    if (typeof obj !== 'object' || obj === null) {
+      throw new Error('omit() requires an object');
+    }
+
+    const result = { ...obj };
+    keys.forEach(key => delete result[key]);
+    return result;
+  };
+}
+
+/**
+ * Deep clone
+ */
+function clone(obj) {
+  if (obj === null || typeof obj !== 'object') {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map(clone);
+  }
+
+  return Object.keys(obj).reduce((acc, key) => {
+    acc[key] = clone(obj[key]);
+    return acc;
+  }, {});
+}
+
+/**
+ * Merge objects deeply
+ */
+function merge(...objects) {
+  const result = {};
+
+  for (const obj of objects) {
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        if (typeof obj[key] === 'object' && !Array.isArray(obj[key]) && obj[key] !== null) {
+          result[key] = merge(result[key] || {}, obj[key]);
+        } else {
+          result[key] = obj[key];
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+module.exports = {
+  pipe,
+  map,
+  filter,
+  reduce,
+  sort,
+  unique,
+  chunk,
+  flatten,
+  groupBy,
+  partition,
+  take,
+  drop,
+  zip,
+  pick,
+  omit,
+  clone,
+  merge
+};