anu-verzum 1.0.0

package/dist/index.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _async = _interopRequireDefault(require("./misc/async"));
+var _utils = _interopRequireDefault(require("./misc/utils"));
+var _serverApi = _interopRequireDefault(require("./server-api/server-api"));
+var _elements = require("./core/elements");
+var _reconciler = require("./core/reconciler");
+var _store = _interopRequireDefault(require("./store/store"));
+var _Context = require("./core/components/Context");
+var _Component = require("./core/components/Component");
+var _Fragment = require("./core/components/Fragment");
+var _Connector = _interopRequireDefault(require("./core/components/Connector"));
+var _Feature = _interopRequireDefault(require("./core/components/Feature"));
+var _History = _interopRequireDefault(require("./core/components/History"));
+var _Intl = _interopRequireDefault(require("./core/components/Intl"));
+var _AnulyticsProvider = _interopRequireWildcard(require("./core/components/AnulyticsProvider"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+window.requestIdleCallback = window.requestIdleCallback || function (callBack) {
+  const start = Date.now();
+  return setTimeout(() => {
+    callBack({
+      didTimeout: false,
+      timeRemaining: () => Math.max(0, 50 - (Date.now() - start))
+    });
+  }, 1);
+};
+window.cancelIdleCallback = window.cancelIdleCallback || function (id) {
+  clearTimeout(id);
+};
+const Anu = {
+  Anulytics: {
+    Provider: _AnulyticsProvider.default,
+    trackEvent: _AnulyticsProvider.trackEvent
+  },
+  createContext: _Context.createContext,
+  createElement: _elements.createElement,
+  createRef: _reconciler.createRef,
+  Component: _Component.Component,
+  Fragment: _Fragment.Fragment,
+  render: _reconciler.render,
+  Feature: _Feature.default,
+  History: _History.default,
+  Intl: _Intl.default,
+  Connector: _Connector.default,
+  ServerAPI: _serverApi.default,
+  store: _store.default,
+  Async: _async.default,
+  Utils: _utils.default
+};
+var _default = exports.default = Anu;

package/dist/misc/async.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const asyncMap = (coll, iteratee, callback) => {
+  const collection = Array.isArray(coll) ? coll : [coll];
+  const collLastIndex = collection.length - 1;
+  const results = [];
+  for (let i = 0; i < collection.length; i++) {
+    (index => {
+      const result = iteratee(collection[index]);
+      results.push(result);
+      if (index === collLastIndex) {
+        callback(results);
+      }
+    })(i);
+  }
+};
+const Async = {
+  map: asyncMap
+};
+var _default = exports.default = Async;

package/dist/misc/polyfill.js

@@ -0,0 +1 @@
+"use strict";

package/dist/misc/utils.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const isObject = object => object !== null && typeof object === 'object';
+const deepEqual = (object1, object2) => {
+  const keys1 = Object.keys(object1);
+  const keys2 = Object.keys(object2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    const val1 = object1[key];
+    const val2 = object2[key];
+    const areObjects = isObject(val1) && isObject(val2);
+    if (areObjects && !deepEqual(val1, val2) || !areObjects && val1 !== val2) {
+      return false;
+    }
+  }
+  return true;
+};
+const Utils = {
+  deepEqual
+};
+var _default = exports.default = Utils;

package/dist/server-api/server-api.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const SUCCESS_STATUS_CODES = [200, 201, 202, 203, 204, 205, 206, 207, 208, 226];
+const CLIENT_ERROR_STATUS_CODES = [400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 421, 422, 423, 424, 425, 426, 428, 429, 431, 451];
+const SERVER_ERROR_STATUS_CODES = [500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511];
+const _setXHR = (successHandler, errorHandler) => {
+  const XHR = new XMLHttpRequest();
+  XHR.onload = () => {
+    const {
+      status,
+      response
+    } = XHR;
+    if (SUCCESS_STATUS_CODES.indexOf(status) > -1) {
+      successHandler({
+        status,
+        response: response ? (() => {
+          try {
+            return JSON.parse(response);
+          } catch (e) {
+            console.error('Invalid JSON response:', e.message);
+            return null;
+          }
+        })() : null
+      });
+    } else if (CLIENT_ERROR_STATUS_CODES.indexOf(status) > -1 || SERVER_ERROR_STATUS_CODES.indexOf(status) > -1) {
+      errorHandler({
+        status,
+        response: null
+      });
+    }
+  };
+  return XHR;
+};
+const _trimUrlFromSpaces = url => `${url.replace(/\s/g, '_')}`;
+const _serverGetAPI = (url, params = {}) => (successHandler, errorHandler) => {
+  const XHR = _setXHR(successHandler, errorHandler);
+  let urlWithParams = _trimUrlFromSpaces(url);
+  const urlParamKeys = Object.keys(params);
+  if (urlParamKeys.length > 0) {
+    urlParamKeys.forEach((key, index) => {
+      if (index === 0) {
+        urlWithParams += `?${key}=${params[key]}`;
+      } else {
+        urlWithParams += `&${key}=${params[key]}`;
+      }
+    });
+  }
+  XHR.open('GET', urlWithParams, true);
+  XHR.send();
+};
+const _serverPostAPI = (url, data) => (successHandler, errorHandler) => {
+  if (!data) {
+    return;
+  }
+  const urlParams = `data=${JSON.stringify(data)}`;
+  const XHR = _setXHR(successHandler, errorHandler);
+  XHR.open('POST', url, true);
+  XHR.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
+  XHR.send(urlParams);
+};
+const _serverPutAPI = (url, data) => (successHandler, errorHandler) => {
+  if (!data) {
+    return;
+  }
+  const XHR = _setXHR(successHandler, errorHandler);
+  XHR.open('PUT', url, true);
+  XHR.setRequestHeader('Content-type', 'application/json; charset=utf-8');
+  XHR.send(JSON.stringify(data));
+};
+const _serverDeleteAPI = (url, params = {}) => (successHandler, errorHandler) => {
+  const XHR = _setXHR(successHandler, errorHandler);
+  let urlWithParams = _trimUrlFromSpaces(url);
+  const urlParamKeys = Object.keys(params);
+  if (urlParamKeys.length > 0) {
+    urlParamKeys.forEach((key, index) => {
+      if (index === 0) {
+        urlWithParams += `?${key}=${params[key]}`;
+      } else {
+        urlWithParams += `&${key}=${params[key]}`;
+      }
+    });
+  }
+  XHR.open('DELETE', urlWithParams, true);
+  XHR.send();
+};
+const _serverFileAPI = (url, files, data = {}) => (successHandler, errorHandler) => {
+  if (!files) {
+    return;
+  }
+  const XHR = _setXHR(successHandler, errorHandler);
+  XHR.open('POST', url, true);
+  const formData = new FormData();
+  const formDataFiles = Array.isArray(files) ? files : [files];
+  formDataFiles.forEach((file, index) => {
+    formData.append(index, file);
+  });
+  formData.append('data', JSON.stringify(data));
+  XHR.send(formData);
+};
+const ServerAPI = {
+  get: (url, params) => new Promise(_serverGetAPI(url, params)),
+  post: (url, data) => new Promise(_serverPostAPI(url, data)),
+  put: (url, data) => new Promise(_serverPutAPI(url, data)),
+  delete: (url, params) => new Promise(_serverDeleteAPI(url, params)),
+  file: (url, file, data) => new Promise(_serverFileAPI(url, file, data))
+};
+var _default = exports.default = ServerAPI;

package/dist/store/store.js

@@ -0,0 +1,171 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _AnulyticsProvider = require("../core/components/AnulyticsProvider");
+const createStore = (reducer, initialState, middleware) => {
+  const _currentReducer = reducer;
+  let _currentState = initialState;
+  const _subscribers = [];
+  const _validateAction = action => {
+    if (!action || typeof action !== 'object' || Array.isArray(action)) {
+      throw new Error('Action must be an object!');
+    }
+    if (typeof action.type === 'undefined') {
+      throw new Error('Action must have a type!');
+    }
+  };
+  const _coreDispatch = action => {
+    _validateAction(action);
+    const prevState = {
+      ..._currentState
+    };
+    _currentState = _currentReducer(_currentState, action);
+    (0, _AnulyticsProvider.trackStateChange)(prevState, action, _currentState);
+    _subscribers.forEach(subscriber => {
+      subscriber();
+    });
+  };
+  const getState = () => _currentState;
+  const store = {
+    getState,
+    dispatch: _coreDispatch,
+    subscribe: newListener => {
+      _subscribers.push(newListener);
+    },
+    unsubscribe: listenerToRemove => {
+      const index = _subscribers.indexOf(listenerToRemove);
+      if (index >= 0) {
+        _subscribers.splice(index, 1);
+      }
+    }
+  };
+  if (middleware) {
+    const dispatch = action => store.dispatch(action);
+    store.dispatch = middleware({
+      dispatch,
+      getState
+    })(_coreDispatch);
+  }
+  return store;
+};
+const applyMiddleware = (...middlewares) => store => {
+  if (middlewares.length === 0) {
+    return dispatch => dispatch;
+  }
+  if (middlewares.length === 1) {
+    return middlewares[0](store);
+  }
+  const boundMiddlewares = middlewares.map(middleware => middleware(store));
+  return boundMiddlewares.reduce((a, b) => next => a(b(next)));
+};
+const thunkMiddleware = ({
+  dispatch,
+  getState
+}) => next => action => {
+  if (typeof action === 'function') {
+    return action(dispatch, getState);
+  }
+  return next(action);
+};
+const loggingMiddleware = ({
+  getState
+}) => next => action => {
+  const prevState = {
+    ...getState()
+  };
+  const result = next(action);
+  const nextState = {
+    ...getState()
+  };
+  console.log('\n-----');
+  console.log('Previous state:', prevState);
+  console.log('Dispatching action:', action);
+  console.log('Next state:', nextState);
+  return result;
+};
+const combineReducers = reducers => {
+  const reducerKeys = Object.keys(reducers);
+  return (state = {}, action) => {
+    const nextState = {};
+    const keysLength = reducerKeys.length;
+    for (let i = 0; i < keysLength; i++) {
+      const key = reducerKeys[i];
+      const reducer = reducers[key];
+      const previousStateForKey = state[key];
+      const nextStateForKey = reducer(previousStateForKey, action);
+      nextState[key] = nextStateForKey;
+    }
+    return nextState;
+  };
+};
+const _generateKey = args => {
+  const parts = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const type = typeof arg;
+    if (arg === null) {
+      parts.push('null');
+    } else if (arg === undefined) {
+      parts.push('undefined');
+    } else if (type === 'function') {
+      parts.push(`function:${arg.name || 'anonymous'}:${arg.toString().slice(0, 100)}`);
+    } else if (type === 'symbol') {
+      parts.push(`symbol:${arg.toString()}`);
+    } else if (type === 'object') {
+      try {
+        parts.push(`object:${JSON.stringify(arg)}`);
+      } catch (e) {
+        parts.push(`object:circular:${Object.prototype.toString.call(arg)}`);
+      }
+    } else {
+      parts.push(`${type}:${arg}`);
+    }
+  }
+  return parts.join('|');
+};
+const _memoize = (func, maxSize = 100) => {
+  const cache = new Map();
+  const accessOrder = [];
+  return (...args) => {
+    const key = _generateKey(args);
+    if (cache.has(key)) {
+      const index = accessOrder.indexOf(key);
+      accessOrder.splice(index, 1);
+      accessOrder.push(key);
+      return cache.get(key);
+    }
+    const result = func.apply(null, args);
+    cache.set(key, result);
+    accessOrder.push(key);
+    if (cache.size > maxSize) {
+      const oldestKey = accessOrder.shift();
+      cache.delete(oldestKey);
+    }
+    return result;
+  };
+};
+const createSelector = (dependenciesInput, transformation) => {
+  const dependencies = Array.isArray(dependenciesInput) ? dependenciesInput : [dependenciesInput];
+  const memoizedTransformation = _memoize(transformation);
+  return _memoize(input => {
+    const params = [];
+    dependencies.forEach(func => {
+      params.push(func(input));
+    });
+    return memoizedTransformation.apply(null, params);
+  });
+};
+const store = {
+  combineReducers,
+  createSelector,
+  createStore,
+  middleware: {
+    applyMiddleware,
+    loggingMiddleware,
+    thunkMiddleware
+  }
+};
+var _default = exports.default = store;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "anu-verzum",
+  "version": "1.0.0",
+  "description": "A \"React-like\" UI library that supports JSX syntax, state management, array-rendering, i18n, routing and many more.",
+  "keywords": [
+    "anu-verzum",
+    "UI-library",
+    "React-like",
+    "JSX",
+    "state-management",
+    "routing",
+    "i18n"
+  ],
+  "files": [
+    "dist",
+    "babel-preset.js"
+  ],
+  "homepage": "https://github.com/Anubis-programmer/ANUVerzum#readme",
+  "bugs": {
+    "url": "https://github.com/Anubis-programmer/ANUVerzum/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Anubis-programmer/ANUVerzum.git"
+  },
+  "license": "MIT",
+  "author": "Anubis-programmer",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "babel src --out-dir dist --extensions \".js\" --copy-files",
+    "prepare": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "@babel/plugin-transform-react-jsx": "^7.21.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.21.0",
+    "@babel/core": "^7.21.0",
+    "@babel/preset-env": "^7.21.0"
+  }
+}