@contentstorage/core 0.3.31 → 0.3.32

package/dist/type-generation/get-type-structure.js

@@ -1,6 +1,6 @@
-import * as hash from "hash.js";
+import * as crypto from 'crypto';
 import { TypeGroup } from './model.js';
-import { findTypeById, getTypeDescriptionGroup, isArray, isDate, isHash, isObject, onlyUnique } from './util.js';
+import { findTypeById, getTypeDescriptionGroup, isArray, isDate, isHash, isObject, onlyUnique, } from './util.js';
 function createTypeDescription(typeObj, isUnion) {
     if (isArray(typeObj)) {
         return {
@@ -27,12 +27,19 @@ function getIdByType(typeObj, types, isUnion = false) {
     return typeDesc.id;
 }
 function Hash(content) {
-    return hash.sha1().update(content).digest("hex");
+    // Create a new SHA-1 hash object
+    const sha1Hash = crypto.createHash('sha1');
+    // Update the hash object with the content
+    sha1Hash.update(content);
+    // Calculate the digest in hexadecimal format
+    return sha1Hash.digest('hex');
 }
 function typeObjectMatchesTypeDesc(typeObj, typeDesc, isUnion) {
     if (isArray(typeObj)) {
-        // @ts-expect-error
-        return arraysContainSameElements(typeObj, typeDesc.arrayOfTypes) && typeDesc.isUnion === isUnion;
+        return (
+        // @ts-ignore
+        arraysContainSameElements(typeObj, typeDesc.arrayOfTypes) &&
+            typeDesc.isUnion === isUnion);
     }
     else {
         return objectsHaveSameEntries(typeObj, typeDesc.typeObj);
@@ -41,7 +48,7 @@ function typeObjectMatchesTypeDesc(typeObj, typeDesc, isUnion) {
 function arraysContainSameElements(arr1, arr2) {
     if (arr1 === undefined || arr2 === undefined)
         return false;
-    return arr1.sort().join("") === arr2.sort().join("");
+    return arr1.sort().join('') === arr2.sort().join('');
 }
 function objectsHaveSameEntries(obj1, obj2) {
     if (obj1 === undefined || obj2 === undefined)
@@ -56,10 +63,10 @@ function objectsHaveSameEntries(obj1, obj2) {
 }
 function getSimpleTypeName(value) {
     if (value === null) {
-        return "null";
+        return 'null';
     }
     else if (value instanceof Date) {
-        return "Date";
+        return 'Date';
     }
     else {
         return typeof value;
@@ -126,11 +133,12 @@ function getMergedObjects(typesOfArray, types) {
     return getIdByType(typeObj, types, true);
 }
 function toOptionalKey(key) {
-    return key.endsWith("--?") ? key : `${key}--?`;
+    return key.endsWith('--?') ? key : `${key}--?`;
 }
 function getMergedArrays(typesOfArray, types) {
     // @ts-expect-error
-    const idsOfArrayTypes = typesOfArray?.map((typeDesc) => typeDesc.arrayOfTypes)
+    const idsOfArrayTypes = typesOfArray
+        ?.map((typeDesc) => typeDesc.arrayOfTypes)
         // @ts-expect-error
         .reduce((a, b) => [...a, ...b], [])
         .filter(onlyUnique);
@@ -155,16 +163,18 @@ function getMergedUnion(typesOfArray, types) {
 }
 function getInnerArrayType(typesOfArray, types) {
     // return inner array type
-    const containsUndefined = typesOfArray.includes("undefined");
-    const arrayTypesDescriptions = typesOfArray.map((id) => findTypeById(id, types)).filter((_) => !!_);
-    const allArrayType = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Array).length ===
-        typesOfArray.length;
-    const allArrayTypeWithUndefined = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Array).length + 1 ===
+    const containsUndefined = typesOfArray.includes('undefined');
+    const arrayTypesDescriptions = typesOfArray
+        .map((id) => findTypeById(id, types))
+        .filter((_) => !!_);
+    const allArrayType = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Array).length === typesOfArray.length;
+    const allArrayTypeWithUndefined = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Array).length +
+        1 ===
         typesOfArray.length && containsUndefined;
-    const allObjectTypeWithUndefined = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Object).length + 1 ===
+    const allObjectTypeWithUndefined = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Object).length +
+        1 ===
         typesOfArray.length && containsUndefined;
-    const allObjectType = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Object).length ===
-        typesOfArray.length;
+    const allObjectType = arrayTypesDescriptions.filter((typeDesc) => getTypeDescriptionGroup(typeDesc) === TypeGroup.Object).length === typesOfArray.length;
     if (typesOfArray.length === 0) {
         // no types in array -> empty union type
         return getIdByType([], types, true);
@@ -183,11 +193,11 @@ function getInnerArrayType(typesOfArray, types) {
             return getMergedArrays(arrayTypesDescriptions, types);
         // all array types with posibble undefined, result type = undefined | (*mergedArray*)[]
         if (allArrayTypeWithUndefined) {
-            return getMergedUnion([getMergedArrays(arrayTypesDescriptions, types), "undefined"], types);
+            return getMergedUnion([getMergedArrays(arrayTypesDescriptions, types), 'undefined'], types);
         }
         // all object types with posibble undefined, result type = undefined | *mergedObject*
         if (allObjectTypeWithUndefined) {
-            return getMergedUnion([getMergedObjects(arrayTypesDescriptions, types), "undefined"], types);
+            return getMergedUnion([getMergedObjects(arrayTypesDescriptions, types), 'undefined'], types);
         }
         // if they are mixed or all primitive we cant merge them so we return as mixed union type
         return getMergedUnion(typesOfArray, types);
@@ -197,7 +207,9 @@ export function getTypeStructure(targetObj, // object that we want to create typ
 types = []) {
     switch (getTypeGroup(targetObj)) {
         case TypeGroup.Array:
-            const typesOfArray = targetObj.map((_) => getTypeStructure(_, types).rootTypeId).filter(onlyUnique);
+            const typesOfArray = targetObj
+                .map((_) => getTypeStructure(_, types).rootTypeId)
+                .filter(onlyUnique);
             const arrayInnerTypeId = getInnerArrayType(typesOfArray, types); // create "union type of array types"
             const typeId = getIdByType([arrayInnerTypeId], types); // create type "array of union type"
             return {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@contentstorage/core",
   "author": "Kaido Hussar <kaidohus@gmail.com>",
   "homepage": "https://contentstorage.app",
-  "version": "0.3.31",
+  "version": "0.3.32",
   "type": "module",
   "description": "Fetch content from contentstorage and generate TypeScript types",
   "module": "dist/index.js",
@@ -28,7 +28,6 @@
     "axios": "^1.7.2",
     "chalk": "^4.1.2",
     "es7-shim": "^6.0.0",
-    "hash.js": "^1.0.3",
     "pluralize": "^3.1.0"
   },
   "devDependencies": {