@strapi/typescript-utils 0.0.0-4fc90398602f → 0.0.0-8581854cb3

package/lib/__tests__/generators/schemas/attributes.test.js

@@ -23,11 +23,11 @@ describe('Attributes', () => {
     const schema = { uid: 'api::foo.foo' };
     const attributeName = 'foo';
 
-    const toPropertySignature = (attribute) => {
+    const toPropertySignature = attribute => {
       return attributeToPropertySignature(schema, attributeName, attribute);
     };
 
-    const defaultAssertion = (node) => {
+    const defaultAssertion = node => {
       expect(node.kind).toBe(ts.SyntaxKind.PropertySignature);
       expect(node.name.escapedText).toBe(attributeName);
       expect(node.type.kind).toBe(ts.SyntaxKind.IntersectionType);

package/lib/__tests__/generators/schemas/global.test.js

@@ -17,7 +17,7 @@ describe('Global', () => {
     jest.resetAllMocks();
   });
 
-  const assertGlobalNodeStructure = (node) => {
+  const assertGlobalNodeStructure = node => {
     // "declare global"
     expect(node.kind).toBe(ts.SyntaxKind.ModuleDeclaration);
     expect(node.modifiers).toHaveLength(1);

package/lib/admin/create-tsconfig-file.js

@@ -3,7 +3,7 @@
 const path = require('path');
 const fs = require('fs-extra');
 
-module.exports = async (dest) => {
+module.exports = async dest => {
   const tsConfig = {
     compilerOptions: {
       lib: ['es2019', 'es2020.promise', 'es2020.bigint', 'es2020.string', 'DOM'],

package/lib/compilers/watch.js

@@ -10,7 +10,7 @@ const resolveConfigOptions = require('../utils/resolve-config-options');
  * Prints a diagnostic every time the watch status changes.
  * This is mainly for messages like "Starting compilation" or "Compilation completed".
  */
-const reportWatchStatusChanged = (diagnostic) => {
+const reportWatchStatusChanged = diagnostic => {
   console.info(ts.formatDiagnostic(diagnostic, formatHost));
 };
 
@@ -18,9 +18,9 @@ module.exports = {
   run(configPath) {
     const createProgram = ts.createSemanticDiagnosticsBuilderProgram;
 
-    const { fileNames, options, projectReferences, watchOptions } =
-      resolveConfigOptions(configPath);
-
+    const { fileNames, options, projectReferences, watchOptions } = resolveConfigOptions(
+      configPath
+    );
     const host = ts.createWatchCompilerHost(
       fileNames,
       options,

package/lib/generators/schemas/attributes.js

@@ -1,11 +1,38 @@
 'use strict';
 
+const ts = require('typescript');
 const { factory } = require('typescript');
 const _ = require('lodash/fp');
 
 const { addImport } = require('./imports');
 const { getTypeNode, toTypeLiteral } = require('./utils');
-const mappers = require('./mappers');
+
+/**
+ * Generate a property signature node for a given attribute
+ *
+ * @param {object} schema
+ * @param {string} attributeName
+ * @param {object} attribute
+ * @returns {object}
+ */
+const attributeToPropertySignature = (schema, attributeName, attribute) => {
+  const baseType = getAttributeType(attributeName, attribute, schema.uid);
+
+  if (baseType === null) {
+    return null;
+  }
+
+  const modifiers = getAttributeModifiers(attribute);
+
+  const nodes = [baseType, ...modifiers];
+
+  return factory.createPropertySignature(
+    undefined,
+    factory.createIdentifier(attributeName),
+    undefined,
+    factory.createIntersectionTypeNode(nodes)
+  );
+};
 
 /**
  * Create the base type node for a given attribute
@@ -37,7 +64,7 @@ const getAttributeType = (attributeName, attribute, uid) => {
  * @param {object} attribute
  * @returns {object[]}
  */
-const getAttributeModifiers = (attribute) => {
+const getAttributeModifiers = attribute => {
   const modifiers = [];
 
   // Required
@@ -124,31 +151,127 @@ const getAttributeModifiers = (attribute) => {
   return modifiers;
 };
 
-/**
- * Generate a property signature node for a given attribute
- *
- * @param {object} schema
- * @param {string} attributeName
- * @param {object} attribute
- * @returns {object}
- */
-const attributeToPropertySignature = (schema, attributeName, attribute) => {
-  const baseType = getAttributeType(attributeName, attribute, schema.uid);
-
-  if (baseType === null) {
-    return null;
-  }
-
-  const modifiers = getAttributeModifiers(attribute);
-
-  const nodes = [baseType, ...modifiers];
+const mappers = {
+  string() {
+    return ['StringAttribute'];
+  },
+  text() {
+    return ['TextAttribute'];
+  },
+  richtext() {
+    return ['RichTextAttribute'];
+  },
+  password() {
+    return ['PasswordAttribute'];
+  },
+  email() {
+    return ['EmailAttribute'];
+  },
+  date() {
+    return ['DateAttribute'];
+  },
+  time() {
+    return ['TimeAttribute'];
+  },
+  datetime() {
+    return ['DateTimeAttribute'];
+  },
+  timestamp() {
+    return ['TimestampAttribute'];
+  },
+  integer() {
+    return ['IntegerAttribute'];
+  },
+  biginteger() {
+    return ['BigIntegerAttribute'];
+  },
+  float() {
+    return ['FloatAttribute'];
+  },
+  decimal() {
+    return ['DecimalAttribute'];
+  },
+  uid({ attribute, uid }) {
+    const { targetField, options } = attribute;
+
+    // If there are no params to compute, then return the attribute type alone
+    if (targetField === undefined && options === undefined) {
+      return ['UIDAttribute'];
+    }
+
+    const params = [];
+
+    // If the targetField property is defined, then reference it,
+    // otherwise, put `undefined` keyword type nodes as placeholders
+    const targetFieldParams = _.isUndefined(targetField)
+      ? [
+          factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
+          factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
+        ]
+      : [factory.createStringLiteral(uid), factory.createStringLiteral(targetField)];
+
+    params.push(...targetFieldParams);
+
+    // If the options property is defined, transform it to
+    // a type literral node and add it to the params list
+    if (_.isObject(options)) {
+      params.push(toTypeLiteral(options));
+    }
+
+    return ['UIDAttribute', params];
+  },
+  enumeration({ attribute }) {
+    const { enum: enumValues } = attribute;
+
+    return ['EnumerationAttribute', [toTypeLiteral(enumValues)]];
+  },
+  boolean() {
+    return ['BooleanAttribute'];
+  },
+  json() {
+    return ['JSONAttribute'];
+  },
+  media() {
+    return ['MediaAttribute'];
+  },
+  relation({ uid, attribute }) {
+    const { relation, target } = attribute;
+
+    const isMorphRelation = relation.toLowerCase().includes('morph');
+
+    if (isMorphRelation) {
+      return [
+        'RelationAttribute',
+        [factory.createStringLiteral(uid, true), factory.createStringLiteral(relation, true)],
+      ];
+    }
+
+    return [
+      'RelationAttribute',
+      [
+        factory.createStringLiteral(uid, true),
+        factory.createStringLiteral(relation, true),
+        factory.createStringLiteral(target, true),
+      ],
+    ];
+  },
+  component({ attribute }) {
+    const target = attribute.component;
+    const params = [factory.createStringLiteral(target, true)];
+
+    if (attribute.repeatable) {
+      params.push(factory.createTrue());
+    }
+
+    return ['ComponentAttribute', params];
+  },
+  dynamiczone({ attribute }) {
+    const componentsParam = factory.createTupleTypeNode(
+      attribute.components.map(component => factory.createStringLiteral(component))
+    );
 
-  return factory.createPropertySignature(
-    undefined,
-    factory.createIdentifier(attributeName),
-    undefined,
-    factory.createIntersectionTypeNode(nodes)
-  );
+    return ['DynamicZoneAttribute', [componentsParam]];
+  },
 };
 
 module.exports = attributeToPropertySignature;

package/lib/generators/schemas/global.js

@@ -1,31 +1,10 @@
 'use strict';
 
-/* eslint-disable no-bitwise */
-
 const ts = require('typescript');
 const { factory } = require('typescript');
 
 const { getSchemaInterfaceName } = require('./utils');
 
-/**
- *
- * @param {object} schemaDefinition
- * @param {ts.InterfaceDeclaration} schemaDefinition.definition
- * @param {object} schemaDefinition.schema
- */
-const schemaDefinitionToPropertySignature = ({ schema }) => {
-  const { uid } = schema;
-
-  const interfaceTypeName = getSchemaInterfaceName(uid);
-
-  return factory.createPropertySignature(
-    undefined,
-    factory.createStringLiteral(uid, true),
-    undefined,
-    factory.createTypeReferenceNode(factory.createIdentifier(interfaceTypeName))
-  );
-};
-
 /**
  * Generate the global module augmentation block
  *
@@ -67,4 +46,23 @@ const generateGlobalDefinition = (schemasDefinitions = []) => {
   );
 };
 
+/**
+ *
+ * @param {object} schemaDefinition
+ * @param {ts.InterfaceDeclaration} schemaDefinition.definition
+ * @param {object} schemaDefinition.schema
+ */
+const schemaDefinitionToPropertySignature = ({ schema }) => {
+  const { uid } = schema;
+
+  const interfaceTypeName = getSchemaInterfaceName(uid);
+
+  return factory.createPropertySignature(
+    undefined,
+    factory.createStringLiteral(uid, true),
+    undefined,
+    factory.createTypeReferenceNode(factory.createIdentifier(interfaceTypeName))
+  );
+};
+
 module.exports = { generateGlobalDefinition };

package/lib/generators/schemas/imports.js

@@ -18,7 +18,7 @@ module.exports = {
   },
 
   generateImportDefinition() {
-    const formattedImports = imports.map((key) =>
+    const formattedImports = imports.map(key =>
       factory.createImportSpecifier(false, undefined, factory.createIdentifier(key))
     );
 

package/lib/generators/schemas/index.js

@@ -23,7 +23,67 @@ const {
 
 const DEFAULT_OUT_FILENAME = 'schemas.d.ts';
 
-const emitDefinitions = (definitions) => {
+/**
+ * Generate type definitions for Strapi schemas
+ *
+ * @param {object} options
+ * @param {Strapi} options.strapi
+ * @param {{ distDir: string; appDir: string; }} options.dirs
+ * @param {string} [options.outDir]
+ * @param {string} [options.file]
+ * @param {boolean} [options.verbose]
+ */
+const generateSchemasDefinitions = async (options = {}) => {
+  const {
+    strapi,
+    outDir = process.cwd(),
+    file = DEFAULT_OUT_FILENAME,
+    verbose = false,
+    silent = false,
+  } = options;
+
+  const schemas = getAllStrapiSchemas(strapi);
+
+  const schemasDefinitions = Object.values(schemas).map(schema => ({
+    schema,
+    definition: generateSchemaDefinition(schema),
+  }));
+
+  const formattedSchemasDefinitions = schemasDefinitions.reduce((acc, def) => {
+    acc.push(
+      // Definition
+      def.definition,
+
+      // Add a newline between each interface declaration
+      factory.createIdentifier('\n')
+    );
+
+    return acc;
+  }, []);
+
+  const allDefinitions = [
+    // Imports
+    generateImportDefinition(),
+
+    // Add a newline after the import statement
+    factory.createIdentifier('\n'),
+
+    // Schemas
+    ...formattedSchemasDefinitions,
+
+    // Global
+    generateGlobalDefinition(schemasDefinitions),
+  ];
+
+  const output = emitDefinitions(allDefinitions);
+  const formattedOutput = await format(output);
+
+  const definitionFilepath = await saveDefinitionToFileSystem(outDir, file, formattedOutput);
+
+  logDebugInformation(schemasDefinitions, { filepath: definitionFilepath, verbose, silent });
+};
+
+const emitDefinitions = definitions => {
   const nodeArray = factory.createNodeArray(definitions);
 
   const sourceFile = ts.createSourceFile(
@@ -54,7 +114,7 @@ const saveDefinitionToFileSystem = async (dir, file, content) => {
  * @param {string} content
  * @returns {Promise<string>}
  */
-const format = async (content) => {
+const format = async content => {
   const configFile = await prettier.resolveConfigFile();
   const config = configFile
     ? await prettier.resolveConfig(configFile)
@@ -84,7 +144,7 @@ const logDebugInformation = (definitions, options = {}) => {
       colAligns: ['center', 'left', 'left', 'center'],
     });
 
-    const sortedDefinitions = definitions.map((def) => ({
+    const sortedDefinitions = definitions.map(def => ({
       ...def,
       attributesCount: getDefinitionAttributesCount(def.definition),
     }));
@@ -122,64 +182,4 @@ const logDebugInformation = (definitions, options = {}) => {
   }
 };
 
-/**
- * Generate type definitions for Strapi schemas
- *
- * @param {object} options
- * @param {Strapi} options.strapi
- * @param {{ distDir: string; appDir: string; }} options.dirs
- * @param {string} [options.outDir]
- * @param {string} [options.file]
- * @param {boolean} [options.verbose]
- */
-const generateSchemasDefinitions = async (options = {}) => {
-  const {
-    strapi,
-    outDir = process.cwd(),
-    file = DEFAULT_OUT_FILENAME,
-    verbose = false,
-    silent = false,
-  } = options;
-
-  const schemas = getAllStrapiSchemas(strapi);
-
-  const schemasDefinitions = Object.values(schemas).map((schema) => ({
-    schema,
-    definition: generateSchemaDefinition(schema),
-  }));
-
-  const formattedSchemasDefinitions = schemasDefinitions.reduce((acc, def) => {
-    acc.push(
-      // Definition
-      def.definition,
-
-      // Add a newline between each interface declaration
-      factory.createIdentifier('\n')
-    );
-
-    return acc;
-  }, []);
-
-  const allDefinitions = [
-    // Imports
-    generateImportDefinition(),
-
-    // Add a newline after the import statement
-    factory.createIdentifier('\n'),
-
-    // Schemas
-    ...formattedSchemasDefinitions,
-
-    // Global
-    generateGlobalDefinition(schemasDefinitions),
-  ];
-
-  const output = emitDefinitions(allDefinitions);
-  const formattedOutput = await format(output);
-
-  const definitionFilepath = await saveDefinitionToFileSystem(outDir, file, formattedOutput);
-
-  logDebugInformation(schemasDefinitions, { filepath: definitionFilepath, verbose, silent });
-};
-
 module.exports = generateSchemasDefinitions;

package/lib/generators/schemas/schema.js

@@ -8,43 +8,13 @@ const { getSchemaExtendsTypeName, getSchemaInterfaceName, toTypeLiteral } = requ
 const attributeToPropertySignature = require('./attributes');
 const { addImport } = require('./imports');
 
-/**
- * Generate a property signature for the schema's `attributes` field
- *
- * @param {object} schema
- * @returns {ts.PropertySignature}
- */
-const generateAttributePropertySignature = (schema) => {
-  const { attributes } = schema;
-
-  const properties = Object.entries(attributes).map(([attributeName, attribute]) => {
-    return attributeToPropertySignature(schema, attributeName, attribute);
-  });
-
-  return factory.createPropertySignature(
-    undefined,
-    factory.createIdentifier('attributes'),
-    undefined,
-    factory.createTypeLiteralNode(properties)
-  );
-};
-
-const generatePropertyLiteralDefinitionFactory = (schema) => (key) => {
-  return factory.createPropertySignature(
-    undefined,
-    factory.createIdentifier(key),
-    undefined,
-    toTypeLiteral(schema[key])
-  );
-};
-
 /**
  * Generate an interface declaration for a given schema
  *
  * @param {object} schema
  * @returns {ts.InterfaceDeclaration}
  */
-const generateSchemaDefinition = (schema) => {
+const generateSchemaDefinition = schema => {
   const { uid } = schema;
 
   // Resolve the different interface names needed to declare the schema's interface
@@ -57,7 +27,7 @@ const generateSchemaDefinition = (schema) => {
   // Properties whose values can be mapped to a literal type expression
   const literalPropertiesDefinitions = ['info', 'options', 'pluginOptions']
     // Ignore non-existent or empty declarations
-    .filter((key) => !isEmpty(schema[key]))
+    .filter(key => !isEmpty(schema[key]))
     // Generate literal definition for each property
     .map(generatePropertyLiteralDefinitionFactory(schema));
 
@@ -84,4 +54,34 @@ const generateSchemaDefinition = (schema) => {
   return schemaType;
 };
 
+/**
+ * Generate a property signature for the schema's `attributes` field
+ *
+ * @param {object} schema
+ * @returns {ts.PropertySignature}
+ */
+const generateAttributePropertySignature = schema => {
+  const { attributes } = schema;
+
+  const properties = Object.entries(attributes).map(([attributeName, attribute]) => {
+    return attributeToPropertySignature(schema, attributeName, attribute);
+  });
+
+  return factory.createPropertySignature(
+    undefined,
+    factory.createIdentifier('attributes'),
+    undefined,
+    factory.createTypeLiteralNode(properties)
+  );
+};
+
+const generatePropertyLiteralDefinitionFactory = schema => key => {
+  return factory.createPropertySignature(
+    undefined,
+    factory.createIdentifier(key),
+    undefined,
+    toTypeLiteral(schema[key])
+  );
+};
+
 module.exports = { generateSchemaDefinition };

package/lib/generators/schemas/utils.js

@@ -23,7 +23,7 @@ const {
  * @param {Strapi} strapi
  * @returns {object}
  */
-const getAllStrapiSchemas = (strapi) => ({ ...strapi.contentTypes, ...strapi.components });
+const getAllStrapiSchemas = strapi => ({ ...strapi.contentTypes, ...strapi.components });
 
 /**
  * Extract a valid interface name from a schema uid
@@ -33,7 +33,19 @@ const getAllStrapiSchemas = (strapi) => ({ ...strapi.contentTypes, ...strapi.com
  */
 const getSchemaInterfaceName = pipe(replace(/(:.)/, ' '), camelCase, upperFirst);
 
-const getSchemaModelType = (schema) => {
+/**
+ * Get the parent type name to extend based on the schema's nature
+ *
+ * @param {object} schema
+ * @returns {string}
+ */
+const getSchemaExtendsTypeName = schema => {
+  const base = getSchemaModelType(schema);
+
+  return upperFirst(base) + 'Schema';
+};
+
+const getSchemaModelType = schema => {
   const { modelType, kind } = schema;
 
   // Components
@@ -42,25 +54,13 @@ const getSchemaModelType = (schema) => {
   }
 
   // Content-Types
-  if (modelType === 'contentType') {
+  else if (modelType === 'contentType') {
     return kind;
   }
 
   return null;
 };
 
-/**
- * Get the parent type name to extend based on the schema's nature
- *
- * @param {object} schema
- * @returns {string}
- */
-const getSchemaExtendsTypeName = (schema) => {
-  const base = getSchemaModelType(schema);
-
-  return `${upperFirst(base)}Schema`;
-};
-
 /**
  * Get a type node based on a type and its params
  *
@@ -77,7 +77,7 @@ const getTypeNode = (typeName, params = []) => {
  * @param data
  * @returns {ts.TypeNode}
  */
-const toTypeLiteral = (data) => {
+const toTypeLiteral = data => {
   if (isUndefined(data)) {
     return factory.createLiteralTypeNode(ts.SyntaxKind.UndefinedKeyword);
   }
@@ -99,7 +99,7 @@ const toTypeLiteral = (data) => {
   }
 
   if (isArray(data)) {
-    return factory.createTupleTypeNode(data.map((item) => toTypeLiteral(item)));
+    return factory.createTupleTypeNode(data.map(item => toTypeLiteral(item)));
   }
 
   if (isDate(data)) {
@@ -139,7 +139,7 @@ const toTypeLiteral = (data) => {
  * @param {ts.TypeNode} definition
  * @returns {number | null}
  */
-const getDefinitionAttributesCount = (definition) => {
+const getDefinitionAttributesCount = definition => {
   const attributesNode = definition.members.find(propEq('name.escapedText', 'attributes'));
 
   if (!attributesNode) {

package/lib/utils/report-diagnostics.js

@@ -8,7 +8,7 @@ const formatHost = require('./format-host');
  * Report one or several diagnostic to the console
  * @param {ts.Diagnostic[] | ts.Diagnostic} diagnostics
  */
-module.exports = (diagnostics) => {
+module.exports = diagnostics => {
   const formattedDiagnostics = ts.formatDiagnosticsWithColorAndContext(
     Array.isArray(diagnostics) ? diagnostics : [diagnostics],
     formatHost

package/lib/utils/resolve-config-options.js

@@ -4,7 +4,7 @@ const ts = require('typescript');
 
 const logDiagnostics = require('./report-diagnostics');
 
-module.exports = (configPath) => {
+module.exports = configPath => {
   // Parse the tsconfig.json file and resolve every file name & compiler options
   const { errors, ...configOptions } = ts.getParsedCommandLineOfConfigFile(
     configPath,

package/lib/utils/resolve-outdir.js

@@ -1,5 +1,4 @@
 'use strict';
-
 const path = require('path');
 const resolveConfigOptions = require('./resolve-config-options');
 const isUsingTypescript = require('./is-using-typescript');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/typescript-utils",
-  "version": "0.0.0-4fc90398602f",
+  "version": "0.0.0-8581854cb3",
   "description": "Typescript support for Strapi",
   "keywords": [
     "strapi",
@@ -35,5 +35,5 @@
     "node": ">=12.22.0 <=16.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "4fc90398602f4a07f8ae8f04968c48d669992707"
+  "gitHead": "8581854cb3c817ae42b829ea686a1b0702ed9245"
 }

package/lib/generators/schemas/mappers.js

@@ -1,131 +0,0 @@
-'use strict';
-
-const ts = require('typescript');
-const _ = require('lodash/fp');
-
-const { toTypeLiteral } = require('./utils');
-
-const { factory } = ts;
-
-module.exports = {
-  string() {
-    return ['StringAttribute'];
-  },
-  text() {
-    return ['TextAttribute'];
-  },
-  richtext() {
-    return ['RichTextAttribute'];
-  },
-  password() {
-    return ['PasswordAttribute'];
-  },
-  email() {
-    return ['EmailAttribute'];
-  },
-  date() {
-    return ['DateAttribute'];
-  },
-  time() {
-    return ['TimeAttribute'];
-  },
-  datetime() {
-    return ['DateTimeAttribute'];
-  },
-  timestamp() {
-    return ['TimestampAttribute'];
-  },
-  integer() {
-    return ['IntegerAttribute'];
-  },
-  biginteger() {
-    return ['BigIntegerAttribute'];
-  },
-  float() {
-    return ['FloatAttribute'];
-  },
-  decimal() {
-    return ['DecimalAttribute'];
-  },
-  uid({ attribute, uid }) {
-    const { targetField, options } = attribute;
-
-    // If there are no params to compute, then return the attribute type alone
-    if (targetField === undefined && options === undefined) {
-      return ['UIDAttribute'];
-    }
-
-    const params = [];
-
-    // If the targetField property is defined, then reference it,
-    // otherwise, put `undefined` keyword type nodes as placeholders
-    const targetFieldParams = _.isUndefined(targetField)
-      ? [
-          factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
-          factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
-        ]
-      : [factory.createStringLiteral(uid), factory.createStringLiteral(targetField)];
-
-    params.push(...targetFieldParams);
-
-    // If the options property is defined, transform it to
-    // a type literral node and add it to the params list
-    if (_.isObject(options)) {
-      params.push(toTypeLiteral(options));
-    }
-
-    return ['UIDAttribute', params];
-  },
-  enumeration({ attribute }) {
-    const { enum: enumValues } = attribute;
-
-    return ['EnumerationAttribute', [toTypeLiteral(enumValues)]];
-  },
-  boolean() {
-    return ['BooleanAttribute'];
-  },
-  json() {
-    return ['JSONAttribute'];
-  },
-  media() {
-    return ['MediaAttribute'];
-  },
-  relation({ uid, attribute }) {
-    const { relation, target } = attribute;
-
-    const isMorphRelation = relation.toLowerCase().includes('morph');
-
-    if (isMorphRelation) {
-      return [
-        'RelationAttribute',
-        [factory.createStringLiteral(uid, true), factory.createStringLiteral(relation, true)],
-      ];
-    }
-
-    return [
-      'RelationAttribute',
-      [
-        factory.createStringLiteral(uid, true),
-        factory.createStringLiteral(relation, true),
-        factory.createStringLiteral(target, true),
-      ],
-    ];
-  },
-  component({ attribute }) {
-    const target = attribute.component;
-    const params = [factory.createStringLiteral(target, true)];
-
-    if (attribute.repeatable) {
-      params.push(factory.createTrue());
-    }
-
-    return ['ComponentAttribute', params];
-  },
-  dynamiczone({ attribute }) {
-    const componentsParam = factory.createTupleTypeNode(
-      attribute.components.map((component) => factory.createStringLiteral(component))
-    );
-
-    return ['DynamicZoneAttribute', [componentsParam]];
-  },
-};