storyblok-generate-ts 1.8.0 → 1.9.0

package/.eslintrc.cjs

@@ -0,0 +1,9 @@
+module.exports = {
+    extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended', 'prettier'],
+    parser: '@typescript-eslint/parser',
+    plugins: ['@typescript-eslint'],
+    root: true,
+    rules: {
+        '@typescript-eslint/ban-ts-comment': 0
+    }
+};

package/README.md

@@ -31,26 +31,27 @@ $ npm install -D storyblok-generate-ts
 ### Alternative to CLI script: create a NodeJS javascript file
 
 #### Example:
+
 ```js
-const storyblokToTypescript = require('storyblok-generate-ts')
+const storyblokToTypescript = require('src/index')
 
 storyblokToTypescript({
-  // required
-  componentsJson: require('./components.xxx.json'), // pull components with storyblok
-  // required
-  path: __dirname + '/src/typings/generated/components-schema.ts', // make sure path exists
-  // optional type prefix (default: none)
-  titlePrefix: '',
-  // optional type name suffix (default: [Name]_Storyblok)
-  titleSuffix: '_storyblok',
-  // optional compilerOptions which get passed through to json-schema-to-typescript
-  compilerOptions: {
-    unknownAny: false,
-    bannerComment: '',
-    unreachableDefinitions: true
-  }
-  // optional function for custom types (key, obj) => {}
-  // customTypeParser: exampleCustomParser
+    // required
+    componentsJson: require('./components.xxx.json'), // pull components with storyblok
+    // required
+    path: __dirname + '/src/typings/generated/components-schema.ts', // make sure path exists
+    // optional type prefix (default: none)
+    titlePrefix: '',
+    // optional type name suffix (default: [Name]_Storyblok)
+    titleSuffix: '_storyblok',
+    // optional compilerOptions which get passed through to json-schema-to-typescript
+    compilerOptions: {
+        unknownAny: false,
+        bannerComment: '',
+        unreachableDefinitions: true
+    }
+    // optional function for custom types (key, obj) => {}
+    // customTypeParser: exampleCustomParser
 })
 ```
 

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,574 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve2, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve2(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var import_json_schema_to_typescript2 = require("json-schema-to-typescript");
+var import_fs = __toESM(require("fs"));
+var import_camelcase = __toESM(require("camelcase"));
+
+// src/defaultCustomMapper.ts
+function defaultCustomMapper(key, obj) {
+  switch (obj.field_type) {
+    case "seo-metatags":
+      return {
+        [key]: {
+          type: "object",
+          properties: {
+            _uid: {
+              type: "string"
+            },
+            title: {
+              type: "string"
+            },
+            plugin: {
+              type: "string"
+            },
+            og_image: {
+              type: "string"
+            },
+            og_title: {
+              type: "string"
+            },
+            description: {
+              type: "string"
+            },
+            twitter_image: {
+              type: "string"
+            },
+            twitter_title: {
+              type: "string"
+            },
+            og_description: {
+              type: "string"
+            },
+            twitter_description: {
+              type: "string"
+            }
+          }
+        }
+      };
+    default:
+      return {};
+  }
+}
+
+// src/genericTypes.ts
+var import_json_schema_to_typescript = require("json-schema-to-typescript");
+var typeFuncs = {
+  "asset": generateAssetTypeIfNotYetGenerated,
+  "multiasset": generateMultiAssetTypeIfNotYetGenerated,
+  "multilink": generateMultiLinkTypeIfNotYetGenerated,
+  "table": generateTableTypeIfNotYetGenerated
+};
+var toGenerateWhitelist = Object.keys(typeFuncs);
+function compileType(obj, name, compilerOptions) {
+  return __async(this, null, function* () {
+    const ts = yield (0, import_json_schema_to_typescript.compile)(obj, name, compilerOptions);
+    toGenerateWhitelist.splice(toGenerateWhitelist.indexOf(name), 1);
+    return ts;
+  });
+}
+function generate(type, title, compilerOptions) {
+  return __async(this, null, function* () {
+    return yield typeFuncs[type](title, compilerOptions);
+  });
+}
+var TYPES = Object.keys(typeFuncs);
+function generateAssetTypeIfNotYetGenerated(title, compilerOptions) {
+  return __async(this, null, function* () {
+    if (!toGenerateWhitelist.includes("asset"))
+      return;
+    const obj = {
+      "$id": "#/asset",
+      title,
+      type: "object",
+      required: ["id", "filename", "name"],
+      properties: {
+        alt: {
+          type: "string"
+        },
+        copyright: {
+          type: "string"
+        },
+        id: {
+          type: "number"
+        },
+        filename: {
+          type: "string"
+        },
+        name: {
+          type: "string"
+        },
+        title: {
+          type: "string"
+        },
+        focus: {
+          type: "string"
+        }
+      }
+    };
+    try {
+      return yield compileType(obj, "asset", compilerOptions);
+    } catch (e) {
+      console.log("ERROR", e);
+    }
+  });
+}
+function generateMultiAssetTypeIfNotYetGenerated(title, compilerOptions) {
+  return __async(this, null, function* () {
+    if (!toGenerateWhitelist.includes("multiasset"))
+      return;
+    const obj = {
+      "$id": "#/multiasset",
+      title,
+      type: "array",
+      items: {
+        type: "object",
+        required: ["id", "filename", "name"],
+        properties: {
+          alt: {
+            type: "string"
+          },
+          copyright: {
+            type: "string"
+          },
+          id: {
+            type: "number"
+          },
+          filename: {
+            type: "string"
+          },
+          name: {
+            type: "string"
+          },
+          title: {
+            type: "string"
+          }
+        }
+      }
+    };
+    try {
+      return yield compileType(obj, "multiasset", compilerOptions);
+    } catch (e) {
+      console.log("ERROR", e);
+    }
+  });
+}
+function generateMultiLinkTypeIfNotYetGenerated(title, compilerOptions) {
+  return __async(this, null, function* () {
+    if (!toGenerateWhitelist.includes("multilink"))
+      return;
+    const obj = {
+      $id: "#/multilink",
+      title,
+      "oneOf": [
+        {
+          type: "object",
+          properties: {
+            cached_url: {
+              type: "string"
+            },
+            linktype: {
+              type: "string"
+            }
+          }
+        },
+        {
+          type: "object",
+          properties: {
+            id: {
+              type: "string"
+            },
+            cached_url: {
+              type: "string"
+            },
+            linktype: {
+              type: "string",
+              enum: ["story"]
+            }
+          }
+        },
+        {
+          type: "object",
+          properties: {
+            url: {
+              type: "string"
+            },
+            cached_url: {
+              type: "string"
+            },
+            linktype: {
+              type: "string",
+              enum: ["asset", "url"]
+            }
+          }
+        },
+        {
+          type: "object",
+          properties: {
+            email: {
+              type: "string"
+            },
+            linktype: {
+              type: "string",
+              enum: ["email"]
+            }
+          }
+        }
+      ]
+    };
+    try {
+      return yield compileType(obj, "multilink", compilerOptions);
+    } catch (e) {
+      console.log("ERROR", e);
+    }
+  });
+}
+function generateTableTypeIfNotYetGenerated(title, compilerOptions) {
+  return __async(this, null, function* () {
+    if (!toGenerateWhitelist.includes("table"))
+      return;
+    const obj = {
+      $id: "#/table",
+      title,
+      type: "object",
+      required: ["tbody", "thead"],
+      properties: {
+        thead: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["_uid", "component"],
+            properties: {
+              _uid: {
+                type: "string"
+              },
+              value: {
+                type: "string"
+              },
+              component: {
+                type: "number"
+              }
+            }
+          }
+        },
+        tbody: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["_uid", "component", "body"],
+            properties: {
+              _uid: {
+                type: "string"
+              },
+              body: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    _uid: {
+                      type: "string"
+                    },
+                    value: {
+                      type: "string"
+                    },
+                    component: {
+                      type: "number"
+                    }
+                  }
+                }
+              },
+              component: {
+                type: "number"
+              }
+            }
+          }
+        }
+      }
+    };
+    try {
+      return yield compileType(obj, "table", compilerOptions);
+    } catch (e) {
+      console.log("ERROR", e);
+    }
+  });
+}
+
+// src/index.ts
+function storyblokToTypescript({
+  componentsJson = { components: [] },
+  compilerOptions = {},
+  customTypeParser,
+  path = "src/typings/generated/components-schema.ts",
+  titleSuffix = "_storyblok",
+  titlePrefix = ""
+}) {
+  compilerOptions = __spreadValues({
+    unknownAny: false,
+    bannerComment: "",
+    unreachableDefinitions: true
+  }, compilerOptions);
+  const tsString = [];
+  const getTitle = (t) => titlePrefix + t + titleSuffix;
+  const groupUuids = {};
+  componentsJson.components.forEach((value) => {
+    if (value.component_group_uuid) {
+      if (!groupUuids[value.component_group_uuid]) {
+        groupUuids[value.component_group_uuid] = [];
+      }
+      groupUuids[value.component_group_uuid].push((0, import_camelcase.default)(getTitle(value.name), {
+        pascalCase: true
+      }));
+    }
+  });
+  function genTsSchema() {
+    return __async(this, null, function* () {
+      for (const values of componentsJson.components) {
+        const obj = {
+          "$id": "#/" + values.name,
+          title: getTitle(values.name),
+          type: "object"
+        };
+        obj.properties = yield typeMapper(values.schema, obj.title);
+        obj.properties._uid = {
+          type: "string"
+        };
+        obj.properties.component = {
+          type: "string",
+          enum: [values.name]
+        };
+        if (values.name === "global" || values.name === "page") {
+          obj.properties.uuid = {
+            type: "string"
+          };
+        }
+        const requiredFields = ["_uid", "component"];
+        Object.keys(values.schema).forEach((key) => {
+          if (values.schema[key].required) {
+            requiredFields.push(key);
+          }
+        });
+        if (requiredFields.length) {
+          obj.required = requiredFields;
+        }
+        try {
+          const ts = yield (0, import_json_schema_to_typescript2.compile)(obj, values.name, compilerOptions);
+          tsString.push(ts);
+        } catch (e) {
+          console.log("ERROR", e);
+        }
+      }
+    });
+  }
+  function typeMapper() {
+    return __async(this, arguments, function* (schema = {}, title) {
+      const parseObj = {};
+      for (const key of Object.keys(schema)) {
+        const obj = {};
+        const schemaElement = schema[key];
+        const type = schemaElement.type;
+        if (TYPES.includes(type)) {
+          const ts = yield generate(type, getTitle(type), compilerOptions);
+          if (ts) {
+            tsString.push(ts);
+          }
+        } else if (type === "custom") {
+          Object.assign(parseObj, defaultCustomMapper(key, schemaElement));
+          if (typeof customTypeParser === "function") {
+            Object.assign(parseObj, customTypeParser(key, schemaElement));
+          }
+          continue;
+        }
+        const schemaType = parseType(type);
+        if (!schemaType) {
+          continue;
+        }
+        obj[key] = {
+          type: schemaType
+        };
+        if (Array.isArray(schemaElement.options) && schemaElement.options.length) {
+          const items = schemaElement.options.map((item) => item.value);
+          if (type === "option" && schemaElement.exclude_empty_option !== true) {
+            items.unshift("");
+          }
+          if (schemaType === "string") {
+            obj[key].enum = items;
+          } else {
+            obj[key].items = {
+              enum: items
+            };
+          }
+        }
+        if (TYPES.includes(type)) {
+          obj[key].tsType = (0, import_camelcase.default)(getTitle(type), {
+            pascalCase: true
+          });
+        } else if (type === "bloks") {
+          if (schemaElement.restrict_components) {
+            if (schemaElement.restrict_type === "groups") {
+              if (Array.isArray(schemaElement.component_group_whitelist) && schemaElement.component_group_whitelist.length) {
+                let currentGroupElements = [];
+                schemaElement.component_group_whitelist.forEach((groupId) => {
+                  const currentGroup = groupUuids[groupId];
+                  if (Array.isArray(currentGroup)) {
+                    currentGroupElements = [...currentGroupElements, ...currentGroup];
+                  } else {
+                    console.log("Group has no members: ", groupId);
+                  }
+                });
+                if (currentGroupElements.length == 0) {
+                  obj[key].tsType = `never[]`;
+                } else {
+                  obj[key].tsType = `(${currentGroupElements.join(" | ")})[]`;
+                }
+              }
+            } else {
+              if (Array.isArray(schemaElement.component_whitelist) && schemaElement.component_whitelist.length) {
+                obj[key].tsType = `(${schemaElement.component_whitelist.map((i) => (0, import_camelcase.default)(getTitle(i), {
+                  pascalCase: true
+                })).join(" | ")})[]`;
+              } else {
+                console.log("No whitelisted component found");
+              }
+            }
+          } else {
+            console.log("Type: bloks array but not whitelisted (will result in all elements):", title);
+          }
+        }
+        Object.assign(parseObj, obj);
+      }
+      return parseObj;
+    });
+  }
+  function parseType(type) {
+    if (TYPES.includes(type))
+      return type;
+    switch (type) {
+      case "text":
+        return "string";
+      case "bloks":
+        return "array";
+      case "option":
+        return "string";
+      case "options":
+        return "array";
+      case "number":
+        return "number";
+      case "image":
+        return "string";
+      case "boolean":
+        return "boolean";
+      case "textarea":
+        return "string";
+      case "markdown":
+        return "string";
+      case "richtext":
+        return "any";
+      case "datetime":
+        return "string";
+      default:
+        return null;
+    }
+  }
+  genTsSchema().then(() => {
+    import_fs.default.writeFileSync(path, tsString.join("\n"));
+  });
+}
+
+// src/cli.ts
+var import_path = require("path");
+var [, , ...args] = process.argv;
+var parseValue = (value) => {
+  if (value.match(/^(true|false)$/)) {
+    return value === "true";
+  }
+  if (value.match(/^[\d.]+$/)) {
+    return Number(value);
+  }
+  return value;
+};
+var props = {};
+args.forEach((key) => {
+  const [name, value] = key.split("=").map((i) => i.trim());
+  if (name.match(/\w+\.\w+/)) {
+    const [objectName, objectProperty] = name.split(".");
+    props[objectName] = props[objectName] || {};
+    props[objectName][objectProperty] = parseValue(value);
+  } else {
+    props[name] = parseValue(value);
+  }
+});
+if (!props.source) {
+  console.log("there is no source path to components file");
+  process.exit();
+}
+if (props.target && !props.target.endsWith(".ts")) {
+  props.target += ".d.ts";
+}
+var options = {
+  componentsJson: require((0, import_path.resolve)(props.source)),
+  compilerOptions: props.compilerOptions || {},
+  path: (0, import_path.resolve)(props.target || "./storyblok-component-types.d.ts")
+};
+if (props.titlePrefix) {
+  options.titlePrefix = props.titlePrefix;
+}
+if (props.titleSuffix) {
+  options.titleSuffix = props.titleSuffix;
+}
+if (props.customTypeParser) {
+  options.customTypeParser = require((0, import_path.resolve)(props.customTypeParser));
+}
+storyblokToTypescript(options);

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import { Options } from 'json-schema-to-typescript';
+import { JSONSchema4 } from 'json-schema';
+
+declare type CompilerOptions = Partial<Options>;
+interface StoryblokTsOptions {
+    componentsJson: {
+        components: JSONSchema4[];
+    };
+    customTypeParser?: (key: string, options: JSONSchema4) => void;
+    compilerOptions?: CompilerOptions;
+    path?: string;
+    titleSuffix?: string;
+    titlePrefix?: string;
+}
+
+declare function storyblokToTypescript({ componentsJson, compilerOptions, customTypeParser, path, titleSuffix, titlePrefix }: StoryblokTsOptions): void;
+
+export { storyblokToTypescript as default };