storyblok 4.14.3 → 4.15.0

package/dist/index.mjs

@@ -5299,6 +5299,121 @@ const storyblokSchemas = /* @__PURE__ */ new Map([
   ["richtext", getRichtextJSONSchema]
 ]);
 
+function generateStoryblokImports(storyblokPropertyTypes, STORY_TYPE) {
+  const imports = [];
+  const needsISbStoryData = storyblokPropertyTypes.has(STORY_TYPE);
+  if (needsISbStoryData) {
+    imports.push(`import type { ${STORY_TYPE} } from '@storyblok/js';`);
+    storyblokPropertyTypes.delete(STORY_TYPE);
+  }
+  if (storyblokPropertyTypes.size > 0) {
+    const typeImports = Array.from(storyblokPropertyTypes).map((type) => {
+      const pascalType = toPascalCase(type);
+      return `Storyblok${pascalType}`;
+    });
+    imports.push(`import type { ${typeImports.join(", ")} } from '../storyblok.d.ts';`);
+  }
+  return imports;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasIdentifier(content, identifier) {
+  const regex = new RegExp(`\\b${escapeRegExp(identifier)}\\b`, "g");
+  return regex.test(content);
+}
+function detectUsedStoryblokTypes(content, storyblokPropertyTypes, STORY_TYPE) {
+  const usedTypes = [];
+  if (content.includes(STORY_TYPE)) {
+    usedTypes.push(STORY_TYPE);
+  }
+  Array.from(storyblokPropertyTypes).forEach((type) => {
+    const pascalType = toPascalCase(type);
+    if (content.includes(`Storyblok${pascalType}`)) {
+      usedTypes.push(type);
+    }
+  });
+  return usedTypes;
+}
+function detectUsedDatasourceTypes(content, datasourceResults) {
+  return datasourceResults.filter((ds) => hasIdentifier(content, ds.title)).map((ds) => ds.title);
+}
+function detectReferencedComponents(content, currentTitle, componentResults) {
+  return componentResults.filter((c) => c.title !== currentTitle && hasIdentifier(content, c.title)).map((c) => c.title);
+}
+function generateComponentImports(componentContent, componentTitle, storyblokPropertyTypes, datasourceResults, componentResults, STORY_TYPE) {
+  const imports = [];
+  const usedStoryblokTypes = detectUsedStoryblokTypes(
+    componentContent,
+    storyblokPropertyTypes,
+    STORY_TYPE
+  );
+  if (usedStoryblokTypes.length > 0) {
+    const hasISbStoryData = usedStoryblokTypes.includes(STORY_TYPE);
+    const otherTypes = usedStoryblokTypes.filter((t) => t !== STORY_TYPE);
+    if (hasISbStoryData) {
+      imports.push(`import type { ${STORY_TYPE} } from '@storyblok/js';`);
+    }
+    if (otherTypes.length > 0) {
+      const typeImports = otherTypes.map((type) => {
+        const pascalType = toPascalCase(type);
+        return `Storyblok${pascalType}`;
+      });
+      imports.push(`import type { ${typeImports.join(", ")} } from '../storyblok.d.ts';`);
+    }
+  }
+  const usedDatasourceTypes = detectUsedDatasourceTypes(componentContent, datasourceResults);
+  if (usedDatasourceTypes.length > 0) {
+    imports.push(`import type { ${usedDatasourceTypes.join(", ")} } from './datasource-types.d.ts';`);
+  }
+  const referencedComponents = detectReferencedComponents(
+    componentContent,
+    componentTitle,
+    componentResults
+  );
+  if (referencedComponents.length > 0) {
+    const componentImportsStr = referencedComponents.map((name) => `import type { ${name} } from './${name}.d.ts';`).join("\n");
+    imports.push(componentImportsStr);
+  }
+  return imports;
+}
+function createDatasourcesFile(datasourceResults, typeDefs) {
+  if (datasourceResults.length === 0) {
+    return null;
+  }
+  const content = [
+    ...typeDefs,
+    ...datasourceResults.map((r) => r.content)
+  ].join("\n");
+  return { name: "datasource-types", content };
+}
+function createContentTypesFile(contentTypeBloks, typeDefs) {
+  if (contentTypeBloks.size === 0) {
+    return null;
+  }
+  const contentTypeNames = Array.from(contentTypeBloks);
+  const imports = contentTypeNames.map((name) => `import type { ${name} } from './${name}.d.ts';`).join("\n");
+  const typeUnion = contentTypeNames.length > 0 ? contentTypeNames.join("\n  | ") : "never";
+  const typeDefinition = `export type ContentType =
+  | ${typeUnion};`;
+  const content = [
+    ...typeDefs,
+    imports,
+    typeDefinition
+  ].join("\n");
+  return { name: "content-types", content };
+}
+function createComponentFile(componentResult, typeDefs, componentImports) {
+  return {
+    name: componentResult.title,
+    content: [
+      ...typeDefs,
+      ...componentImports,
+      componentResult.content
+    ].join("\n")
+  };
+}
+
 const STORY_TYPE = "ISbStoryData";
 const DEFAULT_COMPONENT_FILENAME = "storyblok-components";
 const DEFAULT_TYPEDEFS_HEADER = [
@@ -5390,6 +5505,9 @@ const getComponentType = (componentName, options) => {
   return isFirstCharacterNumber ? `_${componentType}` : componentType;
 };
 const getComponentPropertiesTypeAnnotations = async (component, options, spaceData, customFieldsParser) => {
+  if (!component.schema || typeof component.schema !== "object") {
+    return {};
+  }
   return Object.entries(component.schema).reduce(async (accPromise, [key, value]) => {
     const acc = await accPromise;
     if (key.startsWith("tab-")) {
@@ -5551,6 +5669,9 @@ const generateTypes = async (spaceData, options = {
     const datasourcesSchema = spaceData.datasources.map(async (datasource) => {
       const allComponentTypes = resolvedComponentsSchema.map((schema) => schema.title);
       const enumValues = datasource.entries?.filter((d) => d.value).map((d) => d.value);
+      if (!datasource.slug) {
+        return null;
+      }
       const type = getDatasourceTypeTitle(datasource.slug);
       if (allComponentTypes.includes(type)) {
         console.warn(`Warning: Datasource type "${type}" conflicts with existing component type`);
@@ -5563,7 +5684,10 @@ const generateTypes = async (spaceData, options = {
       };
       return datasourceSchema;
     });
-    const resolvedDatasourcesSchema = await Promise.all(datasourcesSchema);
+    const resolvedDatasourcesSchemaWithNulls = await Promise.all(datasourcesSchema);
+    const resolvedDatasourcesSchema = resolvedDatasourcesSchemaWithNulls.filter((s) => s !== null);
+    const componentTitles = new Set(resolvedComponentsSchema.map((s) => s.title).filter(Boolean));
+    const datasourceTitles = new Set(resolvedDatasourcesSchema.map((s) => s.title).filter(Boolean));
     const contentTypeSchema = {
       $id: `#/ContentType`,
       title: "ContentType",
@@ -5576,26 +5700,48 @@ const generateTypes = async (spaceData, options = {
       contentTypeSchema
     ];
     const result = await Promise.all(schemas.map(async (schema) => {
-      return await compile(schema, schema.title || schema.$id.replace("#/", ""), {
-        additionalProperties: !options.strict,
-        bannerComment: "",
-        ...compilerOptions
-      });
+      const title = schema.title || schema.$id.replace("#/", "");
+      return {
+        title,
+        content: await compile(schema, title, {
+          additionalProperties: !options.strict,
+          bannerComment: "",
+          ...compilerOptions
+        }),
+        isComponent: componentTitles.has(title),
+        isDatasource: datasourceTitles.has(title)
+      };
     }));
-    const imports = [];
-    const needsISbStoryData = storyblokPropertyTypes.has(STORY_TYPE);
-    if (needsISbStoryData) {
-      imports.push(`import type { ${STORY_TYPE} } from '@storyblok/js';`);
-      storyblokPropertyTypes.delete(STORY_TYPE);
-    }
-    if (storyblokPropertyTypes.size > 0) {
-      const typeImports = Array.from(storyblokPropertyTypes).map((type) => {
-        const pascalType = toPascalCase(type);
-        return `Storyblok${pascalType}`;
-      });
-      imports.push(`import type { ${typeImports.join(", ")} } from '../storyblok.d.ts';`);
+    const imports = generateStoryblokImports(storyblokPropertyTypes, STORY_TYPE);
+    if (options.separateFiles) {
+      const files = [];
+      const datasourceResults = result.filter((r) => r.isDatasource);
+      const componentResults = result.filter((r) => r.isComponent);
+      const datasourcesFile = createDatasourcesFile(datasourceResults, typeDefs);
+      if (datasourcesFile) {
+        files.push(datasourcesFile);
+      }
+      const contentTypesFile = createContentTypesFile(
+        contentTypeBloks,
+        typeDefs
+      );
+      if (contentTypesFile) {
+        files.push(contentTypesFile);
+      }
+      for (const componentResult of componentResults) {
+        const componentImports = generateComponentImports(
+          componentResult.content,
+          componentResult.title,
+          storyblokPropertyTypes,
+          datasourceResults,
+          componentResults,
+          STORY_TYPE
+        );
+        files.push(createComponentFile(componentResult, typeDefs, componentImports));
+      }
+      return files;
     }
-    const finalTypeDef = [...typeDefs, ...imports, ...result];
+    const finalTypeDef = [...typeDefs, ...imports, ...result.map((r) => r.content)];
     return [
       ...finalTypeDef
     ].join("\n");
@@ -5603,11 +5749,17 @@ const generateTypes = async (spaceData, options = {
     handleError(error);
   }
 };
-const saveTypesToComponentsFile = async (space, typedefString, options) => {
-  const { filename = DEFAULT_COMPONENT_FILENAME, path } = options;
+const saveTypesToComponentsFile = async (space, typedefData, options) => {
+  const { filename = DEFAULT_COMPONENT_FILENAME, path, separateFiles } = options;
   const resolvedPath = path ? resolve$1(process.cwd(), path, "types", space) : resolvePath(path, `types/${space}`);
   try {
-    await saveToFile(join(resolvedPath, `${filename}.d.ts`), typedefString);
+    if (separateFiles && Array.isArray(typedefData)) {
+      for (const { name, content } of typedefData) {
+        await saveToFile(join(resolvedPath, `${name}.d.ts`), content);
+      }
+    } else if (typeof typedefData === "string") {
+      await saveToFile(join(resolvedPath, `${filename}.d.ts`), typedefData);
+    }
   } catch (error) {
     handleFileSystemError("write", error);
   }
@@ -5801,16 +5953,18 @@ generateCmd.action(async (options, command) => {
   try {
     spinner.start(`Generating types...`);
     const componentsData = await readComponentsFiles({
-      ...options,
       from: space,
-      path
+      path,
+      suffix: options.suffix,
+      verbose
     });
     let dataSourceData;
     try {
       dataSourceData = await readDatasourcesFiles({
-        ...options,
         from: space,
-        path
+        path,
+        suffix: options.suffix,
+        verbose
       });
     } catch (error) {
       if (error instanceof FileSystemError && error.errorId === "file_not_found") {
@@ -5826,17 +5980,21 @@ generateCmd.action(async (options, command) => {
       ...componentsData,
       ...dataSourceData
     };
-    const typedefString = await generateTypes(spaceDataWithComponentsAndDatasources, {
+    const typedefData = await generateTypes(spaceDataWithComponentsAndDatasources, {
       ...options,
       path
     });
-    if (typedefString) {
-      await saveTypesToComponentsFile(space, typedefString, {
+    if (typedefData) {
+      await saveTypesToComponentsFile(space, typedefData, {
         filename: options.filename,
-        path
+        path,
+        separateFiles: options.separateFiles
       });
     }
     spinner.succeed();
+    if (options.separateFiles && options.filename) {
+      konsola.warn(`The --filename option is ignored when using --separate-files`);
+    }
     konsola.ok(`Successfully generated types for space ${space}`, true);
     konsola.br();
   } catch (error) {