@smoxy-io/js-utils 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 smoxy-io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @smoxy-io/js-utils
+
+Useful javascript utilities.
+
+Especially when working with React and Next.js

package/classes/config.js

@@ -0,0 +1,119 @@
+import {isBoolean, isEqual, isFunction, isPlainObject, isString, merge} from 'lodash';
+import {plain} from '../lib/object';
+import {has} from 'lodash/object';
+
+const defaultProps = {};
+
+export class Config {
+  constructor(props = {}) {
+    if (!props) {
+      props = {};
+    }
+
+    if (!isPlainObject(props)) {
+      props = plain(props);
+    }
+
+    merge(this, defaultProps, props);
+  }
+
+  getConfig(key, defaultValue = null) {
+    return getConfig(key, defaultValue);
+  }
+
+  getTitle(defaultValue = '') {
+    return getTitle(defaultValue);
+  }
+
+  getSubTitle(defaultValue = '') {
+    return getSubTitle(defaultValue);
+  }
+
+  getStyles() {
+    return getStyles();
+  }
+}
+
+let config = new Config();
+let setConfigFn = (o) => {};
+
+export const mergeConfig = (delta) => {
+  if (!isPlainObject(delta)) {
+    delta = plain(delta);
+  }
+
+  let _config = new Config(merge({}, config, delta));
+
+  if (isEqual(plain(config), plain(_config))) {
+    // nothing changed, so don't update the config object'
+    return;
+  }
+
+  // console.log('[DEBUG] updating config state', 'old', plain(config), 'delta', delta);
+
+  setConfigFn(_config);
+
+  config = _config;
+};
+
+export const loadConfig = (setConfig) => {
+  if (isFunction(setConfig)) {
+    setConfigFn = setConfig;
+  }
+};
+
+export const getConfig = (key, defaultValue = null) => {
+  if (!key || !isString(key)) {
+    return defaultValue;
+  }
+
+  key = key.trim();
+
+  if (!key || !has(config, key)) {
+    return defaultValue;
+  }
+
+  if (isBoolean(config[key])) {
+    return config[key];
+  }
+
+  if (!config[key]) {
+    return defaultValue;
+  }
+
+  return config[key];
+};
+
+export const getTitle = (defaultValue = '') => {
+  let title = getConfig('title', defaultValue);
+
+  if (title === false) {
+    return '';
+  } else if (title === true) {
+    return defaultValue;
+  }
+
+  return title;
+};
+
+export const getSubTitle = (defaultValue = '') => {
+  let subTitle = getConfig('subTitle', defaultValue);
+
+  if (subTitle === false) {
+    return '';
+  } else if (subTitle === true) {
+    return defaultValue;
+  }
+
+  return subTitle;
+};
+
+export const getStyles = () => {
+  const styles = getConfig('styles', {});
+
+  if (!isPlainObject(styles)) {
+    return {};
+  }
+
+  return styles;
+};

package/classes/env.js

@@ -0,0 +1,111 @@
+import {isEqual, isFunction, isPlainObject, merge} from 'lodash';
+import {plain} from '../lib/object';
+import {isAsync} from '../lib/function';
+
+export const WindowLocation = 'windowLocation';
+export const ParentWindowLocation = 'parentWindowLocation';
+
+export class Env {
+  constructor(props = {}) {
+    if (!isPlainObject(props)) {
+      if (props instanceof Env) {
+        props = plain(props);
+      } else {
+        props = {};
+      }
+    }
+
+    merge(this, {}, props);
+  }
+}
+
+let env = new Env();
+let setEnvFn = (o) => {};   // a noop function by default
+
+export const loadEnv = async (setEnv, apiClient) => {
+  let getEnv = null;
+
+  if (setEnv && !isFunction(setEnv) && isAsync(setEnv.getEnv)) {
+    // setEnv is actually the apiClient. adjust accordingly
+    getEnv = apiClient.getEnv;
+    setEnv = null;
+    apiClient = null;
+  }
+
+  if (isFunction(setEnv)) {
+    setEnvFn = setEnv;
+  }
+
+  const e = {};
+
+  if (window) {
+    e[WindowLocation] = {
+      href: window.location.href,
+      origin: window.location.origin,
+      pathname: window.location.pathname,
+      search: window.location.search,
+      hash: window.location.hash,
+      host: window.location.host,
+      hostname: window.location.hostname,
+      port: window.location.port,
+      protocol: window.location.protocol
+    };
+  }
+
+  if (apiClient && isAsync(apiClient.getEnv)) {
+    getEnv = apiClient.getEnv;
+  }
+
+  if (getEnv) {
+    const envInfo = await getEnv();
+
+    if (!isPlainObject(envInfo)) {
+      mergeEnv(e);
+
+      throw new Error('failed to load env. invalid response: ' + JSON.stringify(envInfo));
+    }
+
+    merge(e, envInfo);
+  }
+
+  mergeEnv(merge(e));
+};
+
+export const mergeEnv = (delta) => {
+  if (!isPlainObject(delta)) {
+    delta = plain(delta);
+  }
+
+  let _env = new Env(merge({}, env, delta));
+
+  if (isEqual(plain(env), plain(_env))) {
+    // nothing changed, so don't update the env object'
+    return;
+  }
+
+  // console.log('[DEBUG] updating env state', 'old', plain(env), 'delta', delta);
+
+  setEnvFn(_env);
+
+  env = _env;
+}
+
+export const getEnv = (name, defaultValue = '') => {
+  const e = env[name];
+
+  if (e) {
+    return e;
+  }
+
+  return defaultValue;
+};
+
+export const getTopWindowLocation = (e = null) => {
+  const _env = e || env;
+  
+  if (_env[ParentWindowLocation] && isPlainObject(_env[ParentWindowLocation])) {
+    return _env[ParentWindowLocation];
+  }
+
+  return _env[WindowLocation];
+}

package/classes/fetch.js

@@ -0,0 +1,97 @@
+
+export class Fetch {}
+
+Fetch.Get = (url) => {
+    return fetch(url, {
+        method: 'GET',
+        headers: headers(url),
+        credentials: 'include',
+    }).then(handleResponse);
+};
+
+Fetch.Post = (url, body) => {
+    return fetch(url, {
+        method: 'POST',
+        headers: headers(url, true),
+        credentials: 'include',
+        body: JSON.stringify(body)
+    }).then(handleResponse);
+};
+
+Fetch.PostForm = (url, body) => {
+    return fetch(url, {
+        method: 'POST',
+        headers: headers(url, true, true),
+        credentials: 'include',
+        body: body
+    }).then(handleResponse);
+}
+
+Fetch.Put = (url, body) => {
+    return fetch(url, {
+        method: 'PUT',
+        headers: headers(url, true),
+        credentials: 'include',
+        body: JSON.stringify(body)
+    }).then(handleResponse);
+}
+
+Fetch.Delete = (url, body = null) => {
+    let opts = {
+        method: 'DELETE',
+        headers: headers(url),
+        credentials: 'include',
+    };
+
+    if (body) {
+        opts.headers = headers(url, true);
+        opts['body'] = JSON.stringify(body);
+    }
+
+    return fetch(url, opts).then(handleResponse);
+};
+
+function headers(url, hasBody = false, formData = false) {
+    let headers = {
+        Accept: 'application/json',
+        'User-Agent': 'pooling-numbers-widget/v1',
+        'Upgrade-Insecure-Requests': 1,
+        'Accept-Encoding': 'gzip, deflate'
+    };
+
+    if (hasBody && !formData) {
+        headers['Content-Type'] = 'application/json'
+    }
+
+    return headers;
+}
+
+function handleResponse(resp) {
+    return resp.text().then((raw) => {
+        let data = null;
+
+        try {
+            data = raw && JSON.parse(raw);
+        } catch (e) {
+            data = {success: false, resp: raw, parseError: e};
+        }
+
+        if (!resp.ok) {
+            // if (AccessDeniedCodes.includes(resp.status)) {
+            //     userService.logout();
+            //
+            // }
+            return Promise.reject(new ResponseNotOkError((data && data.error) || resp.statusText, data));
+        }
+
+        return data;
+    });
+}
+
+export class ResponseNotOkError extends Error {
+    constructor(message, data) {
+        super(message);
+        this.name = 'ResponseNotOkError';
+        this.data = data;
+    }
+}

package/classes/session/jwt.js

@@ -0,0 +1,94 @@
+import {isNumber, isPlainObject, merge} from 'lodash';
+import {plain} from '../../lib/object';
+import {isAsync} from '../../lib/function';
+import {Session} from '../session';
+import {decodeToken} from '../../lib/jwt';
+
+const defaultProps = {
+  token: '',
+  _decodedToken: null,
+};
+
+export class JwtSession extends Session {
+  constructor(props = {}) {
+    if (!isPlainObject(props)) {
+      props = plain(props);
+    }
+
+    if (!props.token && props.jwt) {
+      props.token = props.jwt;
+      delete props.jwt;
+    }
+
+    if (props._decodedToken) {
+      delete props._decodedToken;
+    }
+
+    super(merge({}, defaultProps, props));
+
+    if (this.token) {
+      this._decodedToken = decodeToken(this.token);
+    }
+  }
+
+  async renew(apiClient) {
+    if (!this.token || !this.sid) {
+      throw new Error('cannot renew session: missing token or sid');
+    }
+
+    if (!apiClient || !isAsync(apiClient.renew)) {
+      throw new Error('cannot renew session: no renew function set');
+    }
+
+    const resp = await apiClient.renew(this.token, this.sid);
+
+    if (!resp) {
+      throw new Error('failed to renew session');
+    }
+
+    const newSession = new JwtSession(resp);
+
+    this.token = newSession.token;
+    this.sid = newSession.sid;
+    this._decodedToken = null;
+
+    if (this.token) {
+      this._decodedToken = decodeToken(this.token);
+    }
+  }
+
+  clear() {
+    super.clear();
+
+    this.token = '';
+    this._decodedToken = null;
+  }
+
+  isExpired() {
+    if (!this.token) {
+      return true;
+    }
+
+    if (!this._decodedToken) {
+      this._decodedToken = decodeToken(this.token);
+
+      if (!this._decodedToken) {
+        // invalid token, clear it out
+        this.clear();
+        return true;
+      }
+    }
+
+    if (!this._decodedToken.exp || !isNumber(this._decodedToken.exp)) {
+      // all jwt tokens have an exp claim formatted as a Unix timestamp. if it is missing, assume the token is invalid
+      this.clear();
+      return true;
+    }
+
+    return this._decodedToken.exp * 1000 <= Date.now();
+  }
+
+  isLoggedIn() {
+    return !this.isExpired();
+  }
+}

package/classes/session.js

@@ -0,0 +1,42 @@
+import {isPlainObject, merge} from 'lodash';
+import {plain} from '../lib/object';
+
+const defaultProps = {
+  sid: ''
+};
+
+export class Session {
+  constructor(props = {}) {
+    if (!isPlainObject(props)) {
+      props = plain(props);
+    }
+
+    if (!props.sid && props.sessionId) {
+      props.sid = props.sessionId;
+      delete props.sessionId;
+    }
+
+    if (!props.sid && props.sessionID) {
+      props.sid = props.sessionID;
+      delete props.sessionID;
+    }
+
+    if (props.renew) {
+      delete props.renew;
+    }
+
+    merge(this, {}, defaultProps, props);
+  }
+
+  renew(apiClient) {
+    throw new Error('Session.renew() must be implemented in the child class');
+  }
+
+  clear() {
+    this.sid = '';
+  }
+
+  isLoggedIn() {
+    return this.sid !== '';
+  }
+}

package/lib/function.js

@@ -0,0 +1,12 @@
+import {isFunction} from 'lodash/lang';
+
+export const arrowAsyncNoop = async () => {};
+export const asyncNoop = async function () {};
+
+export const isAsync = (fn) => {
+  return fn && (fn.constructor === arrowAsyncNoop.constructor || fn.constructor === asyncNoop.constructor);
+};
+
+export const isArrow = (fn) => {
+  return fn && isFunction(fn) && fn.prototype === undefined;
+};

package/lib/iframe.js

@@ -0,0 +1,45 @@
+import FrameBus from 'framebus';
+import {isPlainObject, merge} from 'lodash';
+import {mergeEnv, ParentWindowLocation} from '../classes/env';
+import {mergeConfig} from '../classes/config';
+
+export const init = () => {
+  if (window.parent === window) {
+    return;
+  }
+
+  const bus = new FrameBus({
+    targetFrames: [window.parent],
+  });
+
+  bus.emitAsPromise('env').then((pEnv) => {
+    if (pEnv && isPlainObject(pEnv)) {
+      if (!pEnv[ParentWindowLocation]) {
+        pEnv[ParentWindowLocation] = {hostname: 'example.com', origin: 'https://example.com'};
+      }
+
+      mergeEnv(merge({}, pEnv, {inIframe: true}));
+    }
+  }).catch((e) => {
+    console.error('failed to get env from parent frame', e);
+  });
+
+  bus.emitAsPromise('config').then((pConfig) => {
+    mergeConfig(merge({}, pConfig));
+  }).catch((e) => {
+    console.error('failed to get config from parent frame', e);
+  });
+
+  let prevScrollHeight = 0;
+
+  const resizeObserver = new ResizeObserver(() => {
+    const newScrollHeight = document.body.scrollHeight;
+
+    if (prevScrollHeight !== newScrollHeight) {
+      bus.emit('resize', {height: newScrollHeight, width: document.body.scrollWidth});
+      prevScrollHeight = newScrollHeight;
+    }
+  });
+
+  resizeObserver.observe(document.body);
+};

package/lib/jwt.js

@@ -0,0 +1,15 @@
+import {jwtDecode} from 'jwt-decode';
+
+export const decodeToken = (token) => {
+  if (!token) {
+    return null;
+  }
+
+  try {
+    return jwtDecode(token);
+  } catch (e) {
+    console.error('failed to decode token:', e);
+  }
+
+  return null;
+};

package/lib/numbers.js

@@ -0,0 +1,42 @@
+
+const Billion = 1000000000;
+const Million = 1000000;
+const Thousand = 1000;
+
+const BillionSymbol = 'B';
+const MillionSymbol = 'M';
+const ThousandSymbol = 'K';
+
+export const shortFormat = (num = 0.0, currencySymbol = '') => {
+    if (num < Thousand) {
+        return currencySymbol + num.toFixed(0);
+    }
+
+    if (num < Million) {
+        let fmtNum = (num / Thousand).toFixed(1);
+
+        if (fmtNum.includes('.0')) {
+            fmtNum = (num / Thousand).toFixed(0);
+        }
+
+        return currencySymbol + fmtNum + ThousandSymbol;
+    }
+
+    if (num < Billion) {
+        let fmtNum = (num / Million).toFixed(1);
+
+        if (fmtNum.includes('.0')) {
+            fmtNum = (num / Million).toFixed(0);
+        }
+
+        return currencySymbol + fmtNum + MillionSymbol;
+    }
+
+    let fmtNum = (num / Billion).toFixed(1);
+
+    if (fmtNum.includes('.0')) {
+        fmtNum = (num / Billion).toFixed(0);
+    }
+
+    return currencySymbol + fmtNum + BillionSymbol;
+};

package/lib/object.js

@@ -0,0 +1,4 @@
+
+export const plain = (obj) => {
+    return JSON.parse(JSON.stringify(obj));
+};

package/lib/promise.js

@@ -0,0 +1,22 @@
+
+export const fromCallback = (fn, ...args) => {
+    return new Promise((resolve, reject) => {
+        fn(...args, (...cbArgs) => {
+            if (cbArgs.length === 0) {
+                return resolve();
+            }
+
+            const err = cbArgs.shift();
+
+            if (err) {
+                return reject(err);
+            }
+
+            resolve(...cbArgs);
+        });
+    });
+};
+
+export const fromCb = (fn, ...args) => {
+    return fromCallback(fn, ...args);
+};

package/lib/string.js

@@ -0,0 +1,21 @@
+
+export const capitalizeWords = (text) => {
+    if (!text) {
+        return text;
+    }
+
+    const words = text.split(' ');
+
+    const res = [];
+
+    for (const word of words) {
+        if (!word) {
+            res.push('');
+            continue;
+        }
+
+        res.push(word[0].toUpperCase() + word.substring(1));
+    }
+
+    return res.join(' ');
+};

package/lib/styles.js

@@ -0,0 +1,14 @@
+
+export const addGlobalStyle = (css) => {
+  if (!document || !document.head) {
+    return;
+  }
+
+  const head = document.head;
+  const style = document.createElement('style');
+
+  style.type = 'text/css';
+  style.appendChild(document.createTextNode(css));
+
+  head.appendChild(style);
+}

package/lib/time.js

@@ -0,0 +1,13 @@
+import {format} from "date-fns";
+
+export const formatTime = (date) => {
+    return format(date, 'MM/dd/yyyy h:mma');
+};
+
+export const getTime = (timestamp) => {
+    return new Date(timestamp * 1000);
+};
+
+export const formatDate = (date) => {
+    return format(date, 'MM/dd/yyyy');
+}

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@smoxy-io/js-utils",
+  "version": "1.0.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/smoxy-io/js-utils.git"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "framebus": "^6.0.3",
+    "jwt-decode": "^4.0.0",
+    "lodash": "^4.17.21"
+  }
+}