@websolutespa/bom-core 0.0.1

package/dist/index.mjs

@@ -0,0 +1,604 @@
+// src/classNames/classNames.ts
+function isClassNameCollection(value) {
+  return typeof value === "object" && !Array.isArray(value);
+}
+function classNameCollectionToString(className) {
+  const keys = Object.keys(className);
+  const total = keys.length;
+  let classNames = "";
+  for (let i = 0; i < total; i++) {
+    const key = keys[i];
+    const value = className[keys[i]];
+    if (!value) {
+      continue;
+    }
+    classNames = classNames ? `${classNames} ${String(key)}` : String(key);
+  }
+  return classNames;
+}
+function getClassNames(...props) {
+  const total = props.length;
+  let classNames = "";
+  if (total === 0) {
+    return classNames;
+  }
+  for (let i = 0; i < total; i++) {
+    const value = props[i];
+    if (!value) {
+      continue;
+    }
+    if (isClassNameCollection(value)) {
+      classNames += ` ${classNameCollectionToString(value)}`;
+    } else {
+      classNames += ` ${String(value).trim()}`;
+    }
+  }
+  return classNames.trim();
+}
+
+// src/collection/collection.ts
+import pluralize from "pluralize";
+function getCollectionDescription(text) {
+  text = toValidCollectionName(text);
+  const displayName = toDisplayName(text);
+  const pluralName = toPluralName(text);
+  const pluralDisplayName = toPluralName(displayName);
+  const singularName = text;
+  const title = toTitleCase(text);
+  return {
+    displayName,
+    pluralName,
+    pluralDisplayName,
+    singularName,
+    title
+  };
+}
+function isValidCollectionDescription(description) {
+  return description.singularName !== description.pluralName;
+}
+function toValidCollectionName(text) {
+  text = text.trim().replace(/\W/g, "_").replace(/^[_]*(.)/, (_, c) => c);
+  text = camelToSnakeCase(text);
+  text = text.replace(/__/g, "_");
+  return text.toLowerCase();
+}
+function camelToSnakeCase(text) {
+  return text.replace(/[A-Z]/g, (letter, index) => {
+    return index > 0 ? `_${letter.toLowerCase()}` : letter.toLowerCase();
+  });
+}
+function toDisplayName(text) {
+  return toTitleCase(text).replace(/\s/g, "");
+}
+function toPluralName(text) {
+  return pluralize.plural(text);
+}
+function toTitleCase(text) {
+  return text.replace(/^[-_]*(.)/, (_, c) => c.toUpperCase()).replace(/[-_]+(.)/g, (_, c) => " " + c.toUpperCase());
+}
+
+// src/consoleWarn/consoleWarn.ts
+var warningStack = {};
+function consoleWarn(message, component) {
+  if (typeof console === "undefined") {
+    return;
+  }
+  const tag = component ? ` [${component}]` : " ";
+  const log = `[DesignSystem]${tag}: ${message}`;
+  if (warningStack[log]) {
+    return;
+  }
+  warningStack[log] = true;
+  if (process.env.NODE_ENV !== "production") {
+    return console.error(log);
+  }
+  console.warn(log);
+}
+
+// src/utils/index.ts
+function getIsDevelopment() {
+  return process && (!process.env.NODE_ENV || process.env.NODE_ENV === "development");
+}
+var isDevelopment = getIsDevelopment();
+var isBrowser = typeof window !== "undefined";
+function withSchema(component, schema) {
+  return Object.assign(component, schema);
+}
+function asServerProps(props) {
+  return JSON.parse(JSON.stringify(props));
+}
+async function awaitAll(array, callback) {
+  const promises = array.map(callback);
+  return await Promise.all(promises);
+}
+function merge(target, source) {
+  if (source === null) {
+    return source;
+  }
+  if (!target) {
+    if (source && typeof source === "object") {
+      return Object.assign({}, source);
+    } else {
+      return source;
+    }
+  }
+  if (source && typeof source === "object") {
+    Object.keys(source).forEach((key) => {
+      const value = source[key];
+      if (typeof value === "object" && !Array.isArray(value)) {
+        target[key] = merge(target[key], value);
+      } else {
+        target[key] = value;
+      }
+    });
+  }
+  return target;
+}
+function deepCopy(source) {
+  if (Array.isArray(source)) {
+    return source.map((x) => deepCopy(x));
+  } else if (source && typeof source === "object") {
+    const copy = {};
+    Object.keys(source).forEach((key) => {
+      copy[key] = deepCopy(source[key]);
+    });
+    return copy;
+  } else {
+    return source;
+  }
+}
+
+// src/http/http.service.ts
+var defaultOptions = {
+  // method: 'POST', // *GET, POST, PUT, DELETE, etc.
+  // mode: 'cors', // no-cors, *cors, same-origin
+  // cache: 'no-cache', // *default, no-cache, reload, force-cache, only-if-cached
+  // credentials: 'same-origin', // include, *same-origin, omit
+  headers: {
+    "Content-Type": "application/json"
+    // 'Content-Type': 'application/x-www-form-urlencoded',
+  }
+  // redirect: 'follow', // manual, *follow, error
+  // referrerPolicy: 'no-referrer', // no-referrer, *no-referrer-when-downgrade, origin, origin-when-cross-origin, same-origin, strict-origin, strict-origin-when-cross-origin, unsafe-url
+  // body: JSON.stringify(data) // body data type must match 'Content-Type' header
+};
+async function httpFetch(url, options = {}, serviceOptions) {
+  const httpOptions = merge({ ...defaultOptions }, options);
+  const httpResponse = await fetch(url, httpOptions);
+  if (!httpResponse.ok) {
+    throw httpResponse;
+  }
+  const response = await httpResponse.json();
+  return response;
+}
+async function httpGet(url, options = {}) {
+  return await httpFetch(url, { ...options, method: "GET" });
+}
+async function httpPost(url, payload, options = {}) {
+  return await httpFetch(url, { ...options, method: "POST", body: JSON.stringify(payload) });
+}
+async function httpPut(url, payload, options = {}) {
+  return await httpFetch(url, { ...options, method: "PUT", body: JSON.stringify(payload) });
+}
+async function httpPatch(url, payload, options = {}) {
+  return await httpFetch(url, { ...options, method: "PATCH", body: JSON.stringify(payload) });
+}
+async function httpDelete(url, options = {}) {
+  return await httpFetch(url, { ...options, method: "DELETE" });
+}
+
+// src/json/json.service.ts
+var JsonService = class {
+  constructor(items) {
+    this.items = items;
+  }
+  async getItems() {
+    return this.items;
+  }
+  async findOne(id, params = {}) {
+    let items = await this.getItems();
+    params.where = params.where || {};
+    params.where.id = params.where.id || { equals: id };
+    items = this.whereItems_(items, params.where);
+    if (items.length > 0) {
+      return this.decorator_(items[0], params);
+    } else {
+      console.log("JsonService.findOne.notfound", id, params);
+      return void 0;
+    }
+  }
+  async findMany(params = {}) {
+    params.pagination = false;
+    let items = await this.getItems();
+    if (params.where) {
+      items = this.whereItems_(items, params.where);
+    }
+    if (params.sort) {
+      items = this.sortCollection_(items, params.sort);
+    }
+    return items.map((x) => this.decorator_(x, params));
+  }
+  async findPaged(params = {}) {
+    params.pagination = true;
+    let items = await this.getItems();
+    if (params.where) {
+      items = this.whereItems_(items, params.where);
+    }
+    if (params.sort) {
+      items = this.sortCollection_(items, params.sort);
+    }
+    const pagination = this.paginatedItems_(items, params.page, params.limit);
+    pagination.docs = pagination.docs.map((x) => this.decorator_(x, params));
+    return pagination;
+  }
+  async create(payload) {
+    const items = await this.getItems();
+    const item = { ...payload, id: this.newUUID_() };
+    this.items = [...items, item];
+    return item;
+  }
+  async update(payload) {
+    let items = await this.getItems();
+    const index = items.reduce((p, c, i) => {
+      return c.id === payload.id ? i : p;
+    }, -1);
+    if (index !== -1) {
+      const item = { ...items[index], payload };
+      items = [...items];
+      items[index] = item;
+      this.items = items;
+      return item;
+    }
+    throw "not found";
+  }
+  async delete(id) {
+    let items = await this.getItems();
+    const index = items.reduce((p, c, i) => {
+      return c.id === id ? i : p;
+    }, -1);
+    if (index !== -1) {
+      const item = items[index];
+      items = [...items];
+      items.splice(index, 1);
+      this.items = items;
+      return item;
+    }
+    return void 0;
+  }
+  decorator_(item, params = {}) {
+    return item;
+  }
+  newUUID_() {
+    return (/* @__PURE__ */ new Date()).getTime();
+  }
+  // where
+  evaluateValue_(value) {
+    if (typeof value === "object" && value) {
+      return value.id;
+    } else {
+      return value;
+    }
+  }
+  existsClause_(value, exists) {
+    if (typeof exists === "boolean") {
+      return value != null === exists;
+    }
+    return true;
+  }
+  equalsClause_(value, equals) {
+    if (typeof equals !== "undefined") {
+      return this.evaluateValue_(value) === equals;
+    }
+    return true;
+  }
+  inClause_(value, values) {
+    if (Array.isArray(values)) {
+      return values.indexOf(this.evaluateValue_(value)) !== -1;
+    }
+    return true;
+  }
+  notInClause_(value, values) {
+    if (Array.isArray(values)) {
+      return values.indexOf(this.evaluateValue_(value)) === -1;
+    }
+    return true;
+  }
+  likeClause_(value, query) {
+    if (typeof query === "string") {
+      return String(value).toLowerCase().indexOf(query.toLowerCase()) !== -1;
+    }
+    return true;
+  }
+  // old where
+  /*
+  protected where_(items: any[], params: FindParams): any[] {
+    const where = params.where;
+    if (where) {
+      const keys = Object.keys(where);
+      items = items.filter(x => {
+        return keys.reduce<boolean>((p, c) => {
+          const whereValue = where[c];
+          const shouldMatch = Array.isArray(whereValue) ? whereValue : [whereValue];
+          // console.log('key', c, 'value', x[c], 'shouldMatch', shouldMatch);
+          return p && (shouldMatch.indexOf(x[c]) !== -1);
+        }, true);
+      });
+    }
+    return items;
+  }
+  */
+  whereItem_(item, where) {
+    let has = true;
+    if (typeof where === "object") {
+      Object.entries(where).forEach(([k, v]) => {
+        switch (k) {
+          case "and":
+            if (Array.isArray(v)) {
+              has = v.reduce((p, c) => {
+                return p && this.whereItem_(item, c);
+              }, has);
+            }
+            break;
+          case "or":
+            if (Array.isArray(v)) {
+              has = has && v.reduce((p, c) => {
+                return p || this.whereItem_(item, c);
+              }, false);
+            }
+            break;
+          default:
+            if (Array.isArray(v)) {
+            } else if (typeof v === "object") {
+              const value = item[k];
+              has = has && this.existsClause_(value, v.exists);
+              has = has && this.equalsClause_(value, v.equals);
+              has = has && this.inClause_(value, v.in);
+              has = has && this.notInClause_(value, v.not_in);
+              has = has && this.likeClause_(value, v.like);
+            }
+        }
+      });
+    }
+    return has;
+  }
+  whereItems_(items, where) {
+    if (typeof where === "object") {
+      items = items.filter((item) => this.whereItem_(item, where));
+    }
+    return items;
+  }
+  // ^ where
+  // sort
+  sortCollection_(items, sort) {
+    if (sort) {
+      const reverse = sort.indexOf("-") === 0 ? -1 : 1;
+      const key = sort.replace(/^-/, "");
+      items = [...items];
+      items.sort((a, b) => {
+        const aValue = String(a[key]);
+        const bValue = String(b[key]);
+        if (aValue.localeCompare(bValue) < 0) {
+          return -1 * reverse;
+        } else if (aValue.localeCompare(bValue) > 0) {
+          return 1 * reverse;
+        }
+        return 0;
+      });
+    }
+    return items;
+  }
+  // ^ sort
+  // pagination
+  paginatedItems_(items, page = 1, limit = 10) {
+    const totalDocs = items.length;
+    const totalPages = Math.ceil(items.length / limit);
+    const hasNextPage = page < totalPages;
+    const hasPrevPage = page > 1;
+    const index = page - 1;
+    const from = index * limit;
+    const to = Math.min(page * limit, totalDocs);
+    const docs = items.slice(from, to);
+    const pagination = {
+      totalDocs,
+      totalPages,
+      page,
+      limit,
+      hasNextPage,
+      hasPrevPage,
+      nextPage: hasNextPage ? page + 1 : null,
+      prevPage: hasPrevPage ? page - 1 : null,
+      pagingCounter: from + 1
+    };
+    return {
+      docs,
+      ...pagination
+    };
+  }
+  // ^ sort
+};
+
+// src/localized/localized.ts
+function isLocalizedString(value) {
+  let isLocalizedString2 = false;
+  if (value && !Array.isArray(value) && typeof value === "object") {
+    const matchKeys = Object.keys(value).reduce((p, c) => p && /^(\w{2})(-\w{2})?$/.test(c), true);
+    const matchValues = Object.values(value).reduce((p, c) => p && (typeof c === "string" || !c), true);
+    isLocalizedString2 = Boolean(matchKeys && matchValues);
+  }
+  return isLocalizedString2;
+}
+function localizedToString(json, locale = "en", defaultLocale = "en") {
+  const localizedString = json[locale] || json[defaultLocale] || Object.values(json)[0];
+  return localizedString;
+}
+function localizeValue(value, locale = "en", defaultLocale = "en") {
+  if (value) {
+    if (isLocalizedString(value)) {
+      return localizedToString(value, locale, defaultLocale);
+    } else {
+      return localizeItem(value, locale, defaultLocale);
+    }
+  }
+}
+function localizeItem(item, locale = "en", defaultLocale = "en") {
+  if (Array.isArray(item)) {
+    item = item.map((x) => localizeValue(x, locale, defaultLocale));
+  } else if (typeof item === "object") {
+    item = { ...item };
+    Object.keys(item).forEach((key) => {
+      item[key] = localizeValue(item[key], locale, defaultLocale);
+    });
+  }
+  return item;
+}
+
+// src/qs/qs.ts
+function serializeKey(key, parentKey = "") {
+  return parentKey ? `${parentKey}[${key}]` : String(key);
+}
+function serializeParam(key, value, serializedParams = [], parentKey = "") {
+  if (value != null) {
+    if (typeof value === "object") {
+      serializedParams = serializeParams(value, serializedParams, serializeKey(key, parentKey));
+    } else {
+      serializedParams.push({
+        key: serializeKey(key, parentKey),
+        value
+      });
+    }
+  }
+  return serializedParams;
+}
+function serializeParams(params, serializedParams = [], parentKey = "") {
+  if (Array.isArray(params)) {
+    params.forEach((value, key) => {
+      serializedParams = serializeParam(key, value, serializedParams, parentKey);
+    });
+  } else {
+    Object.entries(params).forEach(([key, value]) => {
+      serializedParams = serializeParam(key, value, serializedParams, parentKey);
+    });
+  }
+  return serializedParams;
+}
+function qsSerialize(queryParams = {}) {
+  const params = serializeParams(queryParams);
+  if (params.length) {
+    return params.map((x) => `${x.key}=${x.value}`).join("&");
+  }
+  return "";
+}
+function asEquatable(value) {
+  if (String(parseInt(value)) === value) {
+    return Number(value);
+  }
+  return value;
+}
+function deserializeValue(value) {
+  if (String(parseInt(value)) === value) {
+    return Number(value);
+  } else if (String(value) === "true") {
+    return true;
+  } else if (String(value) === "false") {
+    return false;
+  }
+  return value;
+}
+function deserializeKey(value) {
+  if (String(parseInt(value)) === value) {
+    return Number(value);
+  }
+  return value;
+}
+function deserializeKeys(key) {
+  const keys = key.replace(/[\]]/g, "").split("[").map((x) => deserializeKey(x));
+  return keys;
+}
+function getNextKeyItem(key) {
+  if (typeof key === "number") {
+    return [];
+  } else {
+    return {};
+  }
+}
+function deserializeParam(key, value, deserializedParams = {}) {
+  const keys = deserializeKeys(key);
+  let target = deserializedParams;
+  while (keys.length) {
+    const key2 = keys.shift();
+    if (keys.length === 0) {
+      target[key2] = deserializeValue(value);
+    } else {
+      const next = target[key2] ? target[key2] : target[key2] = getNextKeyItem(keys[0]);
+      target = next;
+    }
+  }
+  return deserializedParams;
+}
+function deserializeParams(params, deserializedParams = {}) {
+  params.forEach((x) => deserializeParam(x[0], x[1], deserializedParams));
+  return deserializedParams;
+}
+function qsDeserialize(query = "", deserializedParams = {}) {
+  if (query.indexOf("?") === 0) {
+    query = query.substring(1);
+  }
+  if (query !== "") {
+    const params = query.split("&").map((x) => x.split("="));
+    if (params.length) {
+      return deserializeParams(params, deserializedParams);
+    }
+  }
+  return deserializedParams;
+}
+
+// src/slug/slug.ts
+function titleToSlug(title) {
+  return title.toString().normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/\s+/g, "-").replace(/&/g, "-and-").replace(/[^\w-]+/g, "").replace(/--+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+
+// src/types/querable.ts
+function toFindParams(idOrParams) {
+  if (typeof idOrParams === "number" || typeof idOrParams === "string") {
+    return { where: { id: idOrParams } };
+  } else {
+    return idOrParams;
+  }
+}
+export {
+  JsonService,
+  asEquatable,
+  asServerProps,
+  awaitAll,
+  camelToSnakeCase,
+  consoleWarn,
+  deepCopy,
+  deserializeKey,
+  deserializeValue,
+  getClassNames,
+  getCollectionDescription,
+  getIsDevelopment,
+  httpDelete,
+  httpFetch,
+  httpGet,
+  httpPatch,
+  httpPost,
+  httpPut,
+  isBrowser,
+  isDevelopment,
+  isLocalizedString,
+  isValidCollectionDescription,
+  localizeItem,
+  localizeValue,
+  localizedToString,
+  merge,
+  qsDeserialize,
+  qsSerialize,
+  titleToSlug,
+  toDisplayName,
+  toFindParams,
+  toPluralName,
+  toTitleCase,
+  toValidCollectionName,
+  withSchema
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@websolutespa/bom-core",
+  "version": "0.0.1",
+  "description": "Core module of the BOM Repository",
+  "keywords": [
+    "bom",
+    "mixer",
+    "core"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/websolutespa/bom.git"
+  },
+  "scripts": {
+    "lint": "eslint *.ts*",
+    "test": "jest",
+    "test-watch": "npm test -- --watch",
+    "coverage:integration": "npm run test -- --coverage",
+    "coverage": "run-s -c --silent coverage:*",
+    "compile": "tsup ./src/index.ts --format esm,cjs --dts --external react",
+    "prepack": "bom prepack",
+    "postpack": "bom postpack"
+  },
+  "peerDependencies": {
+    "next": ">= 12.3.2",
+    "pluralize": ">= 8.0.0"
+  },
+  "devDependencies": {
+    "@websolutespa/bom-cli": "*",
+    "@websolutespa/test": "*",
+    "@websolutespa/tsconfig": "*",
+    "eslint": "^8.36.0",
+    "eslint-config-websolute": "*",
+    "npm-run-all": "^4.1.5",
+    "raw-loader": "^4.0.2",
+    "ts-node": "^10.9.1",
+    "tsup": "^6.7.0",
+    "typescript": "^4.8.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "prepack": {
+    "types": "./dist/index.d.ts",
+    "main": "./dist/index.js",
+    "module": "./dist/index.mjs"
+  },
+  "postpack": {
+    "types": "./src/index.ts",
+    "main": "./src/index.ts"
+  },
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs"
+}