@strapi/typescript-utils 0.0.0-experimental.6340da17068c3bed7fb006e7bcc554c71129e282 → 0.0.0-experimental.63624e21eb5b0713345a0cf2f68f1c40eab427bc

package/dist/generators/common/sources.mjs

@@ -0,0 +1,318 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import * as ts from 'typescript';
+import { kebabCase } from 'lodash';
+import { pathExists, format, emitDefinitions } from '../utils.mjs';
+import { compareCodeUnits } from './compare.mjs';
+
+/**
+ * Shared by the generators of application modules (services, controllers, policies, middlewares):
+ * they find the source files the loaders of @strapi/core register, derive the same uids, and write
+ * one global registry each. Each generator keeps what it reads from a module type and which registry
+ * it writes.
+ */ const { factory } = ts;
+const GLOBAL_NAMESPACE = 'Strapi';
+const REGISTRIES_NAMESPACE = 'Registries';
+// Ordered by precedence when several files resolve to the same uid
+const SOURCE_EXTENSIONS = [
+    '.ts',
+    '.js'
+];
+/**
+ * Mirror of the API loader's name normalization (@strapi/core, loaders/apis.ts): names already in
+ * kebab-case are kept as is, anything else is kebab-cased. Both must agree for the generated uids
+ * to match the ones registered at runtime. Global policies and middlewares (loaders/policies.ts,
+ * loaders/middlewares.ts) are not normalized.
+ */ const isKebabCase = (value)=>/^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/.test(value);
+const normalizeName = (name)=>isKebabCase(name) ? name : kebabCase(name);
+const isSourceFile = (fd)=>fd.isFile() && !fd.name.endsWith('.d.ts') && SOURCE_EXTENSIONS.includes(path.extname(fd.name));
+const byExtensionPrecedence = (a, b)=>SOURCE_EXTENSIONS.indexOf(path.extname(a.name)) - SOURCE_EXTENSIONS.indexOf(path.extname(b.name));
+const toImportSpecifier = (from, to)=>{
+    const specifier = path.relative(from, to).split(path.sep).join('/');
+    return specifier.startsWith('.') ? specifier : `./${specifier}`;
+};
+/**
+ * Add the source files of a directory to `sources`, under the uid returned by `toUID`
+ */ const collectDirectorySources = async (dir, toUID, sources, outDir, logger)=>{
+    if (await pathExists(dir) === false) {
+        return;
+    }
+    const sourceFDs = (await fs.promises.readdir(dir, {
+        withFileTypes: true
+    })).filter(isSourceFile).sort(byExtensionPrecedence);
+    for (const sourceFD of sourceFDs){
+        const basename = path.basename(sourceFD.name, path.extname(sourceFD.name));
+        const uid = toUID(basename);
+        const file = path.join(dir, sourceFD.name);
+        if (sources.has(uid)) {
+            logger.warn(`Several source files resolve to ${uid}, ignoring ${file}`);
+            continue;
+        }
+        sources.set(uid, {
+            uid,
+            file,
+            specifier: toImportSpecifier(outDir, path.join(dir, basename))
+        });
+    }
+};
+/**
+ * Collect the global source files of a kind when `dirs.global` is given (src/<kind>/<name>.{ts,js}
+ * → global::<name>), then the ones of every API (src/api/<api>/<kind>/<name>.{ts,js} →
+ * api::<api>.<name>). The first file to resolve to a uid wins.
+ */ const collectAppSources = async (kind, dirs, outDir, logger)=>{
+    const sources = new Map();
+    if (dirs.global !== undefined) {
+        await collectDirectorySources(dirs.global, (basename)=>`global::${basename}`, sources, outDir, logger);
+    }
+    if (await pathExists(dirs.api) === true) {
+        const apiFDs = (await fs.promises.readdir(dirs.api, {
+            withFileTypes: true
+        })).filter((fd)=>fd.isDirectory() && !fd.name.startsWith('.'));
+        for (const apiFD of apiFDs){
+            const apiName = normalizeName(apiFD.name);
+            await collectDirectorySources(path.join(dirs.api, apiFD.name, kind), (basename)=>`api::${apiName}.${normalizeName(basename)}`, sources, outDir, logger);
+        }
+    }
+    return Array.from(sources.values());
+};
+/**
+ * Keep the sources whose uid the running app registered, sorted by uid
+ */ const filterRegisteredSources = (sources, registered, logger)=>{
+    const registeredUIDs = new Set(Object.keys(registered));
+    return sources.filter((source)=>{
+        if (!registeredUIDs.has(source.uid)) {
+            logger.debug(`${source.uid} is not registered, ignoring ${source.file}`);
+            return false;
+        }
+        return true;
+    }).sort((a, b)=>compareCodeUnits(a.uid, b.uid));
+};
+/**
+ * Application tsconfigs do not enable `allowJs`, so the import of a JS source does not resolve and is
+ * an error type. Unlike `any`, conditional types cannot map it to `unknown`.
+ */ const isTypedSource = (source)=>path.extname(source.file) === '.ts';
+const hasModifier = (statement, kind)=>ts.canHaveModifiers(statement) && (ts.getModifiers(statement) ?? []).some((modifier)=>modifier.kind === kind);
+/**
+ * Whether a top-level statement is `export type <name>` or `export interface <name>`
+ */ const isExportedTypeDeclarationNamed = (statement, name)=>(ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement)) && statement.name.text === name && hasModifier(statement, ts.SyntaxKind.ExportKeyword) === true && hasModifier(statement, ts.SyntaxKind.DefaultKeyword) === false;
+/**
+ * Whether a type declaration can be referenced without type arguments, as the generated file does
+ */ const hasDefaultTypeArguments = (statement)=>(statement.typeParameters ?? []).every((parameter)=>parameter.default !== undefined);
+/**
+ * Whether a top-level statement exports a type under `name`: `export type <name>`,
+ * `export interface <name>`, or an export specifier named `<name>` (`export { <name> }`,
+ * `export { type X as <name> }`, `export type { X as <name> } from './x'`).
+ *
+ * A generic declaration only counts when each of its type parameters has a default: the generated
+ * file references it without type arguments.
+ *
+ * A specifier may name a value rather than a type, or a generic without defaults: its reference in
+ * the generated file does not resolve, and `tsc` reports it there.
+ * TODO @Nico a specifier of a local declaration could be checked like the declaration itself
+ */ const exportsTypeNamed = (statement, name)=>{
+    if (ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement)) {
+        return isExportedTypeDeclarationNamed(statement, name) === true && hasDefaultTypeArguments(statement) === true;
+    }
+    if (ts.isExportDeclaration(statement) && statement.exportClause !== undefined && ts.isNamedExports(statement.exportClause)) {
+        return statement.exportClause.elements.some((element)=>element.name.text === name);
+    }
+    return false;
+};
+/**
+ * The uids of the TypeScript sources whose module exports a type named `name`, such as a service's
+ * `ServiceContract`.
+ *
+ * Each source is parsed on its own, without a program: type generation runs on every `strapi develop`
+ * start, before the compilation, and a program would need the application's tsconfig and its whole
+ * dependency graph. Only top-level declarations and export specifiers are read (see
+ * `exportsTypeNamed`). `export *` is not followed, and a source that cannot be read is skipped with a
+ * warning: both keep the type the source registers without a contract, rather than stopping the
+ * generation.
+ *
+ * JS sources are skipped: their import does not resolve without `allowJs` (see `isTypedSource`).
+ */ const findTypeExports = async (sources, name, logger)=>{
+    // TODO @Nico A JS source could get a contract from a sibling `<name>.d.ts` that exports it: the
+    // extension-less import of the source resolves to that file without `allowJs`.
+    const typedSources = sources.filter(isTypedSource);
+    const verdicts = await Promise.all(typedSources.map(async (source)=>{
+        let content;
+        try {
+            content = await fs.promises.readFile(source.file, 'utf8');
+        } catch (error) {
+            logger.warn(`Could not read ${source.file} to find its ${name} export, typing ${source.uid} without it: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+        const sourceFile = ts.createSourceFile(source.file, content, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+        if (sourceFile.statements.some((statement)=>exportsTypeNamed(statement, name)) === true) {
+            return true;
+        }
+        if (sourceFile.statements.some((statement)=>isExportedTypeDeclarationNamed(statement, name) === true && hasDefaultTypeArguments(statement) === false) === true) {
+            logger.warn(`${source.file} exports ${name} with type parameters that have no default, typing ${source.uid} without it`);
+        }
+        if (sourceFile.statements.some((statement)=>ts.isExportDeclaration(statement) && statement.exportClause === undefined) === true) {
+            logger.debug(`${source.uid}: \`export *\` is not followed to find a ${name} export`);
+        }
+        return false;
+    }));
+    return new Set(typedSources.filter((_, index)=>verdicts[index] === true).map(({ uid })=>uid));
+};
+/**
+ * The type a service or controller source registers:
+ * - `<contract helper><import('<source>').<contract export>>` when the module exports the contract;
+ * - `<helper><typeof import('<source>')>` otherwise, which infers it from the default export;
+ * - `unknown` for a JS source, whose import is an error type without `allowJs` (see `isTypedSource`).
+ *
+ * The contract does not depend on the default export, so the factory can be checked against its own
+ * uid (`Core.ServiceFactory<uid>`). The inferred type does: the generators list those uids in a
+ * marker registry (see `isInferredSource`), which the factory types reject.
+ */ const instanceTypeOf = (helper, logger, contract)=>(source)=>{
+        if (isTypedSource(source) === false) {
+            logger.debug(`${source.uid} has no TypeScript source, registering it as unknown`);
+            return factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+        }
+        if (contract !== undefined && contract.uids.has(source.uid) === true) {
+            logger.debug(`${source.uid} exports ${contract.exportName}, registering it`);
+            return factory.createTypeReferenceNode(contract.helper, [
+                importedType(source, contract.exportName)
+            ]);
+        }
+        return factory.createTypeReferenceNode(helper, [
+            typeofImport(source)
+        ]);
+    };
+/**
+ * Whether a source registers the type its module provides (see `instanceTypeOf`): a TypeScript
+ * source whose module does not export the contract.
+ */ const isInferredSource = (contract)=>(source)=>isTypedSource(source) === true && contract.uids.has(source.uid) === false;
+/**
+ * typeof import('<relative path to the source>')
+ */ const typeofImport = (source)=>factory.createImportTypeNode(factory.createLiteralTypeNode(factory.createStringLiteral(source.specifier, true)), undefined, undefined, undefined, true);
+/**
+ * import('<relative path to the source>').<name>
+ */ const importedType = (source, name)=>factory.createImportTypeNode(factory.createLiteralTypeNode(factory.createStringLiteral(source.specifier, true)), undefined, factory.createIdentifier(name), undefined, false);
+const withDocComment = (node, comment)=>ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, comment, true);
+/**
+ * type <name><TModule> = TModule extends { default: infer TExport }
+ *   ? 0 extends 1 & TExport
+ *     ? unknown
+ *     : TExport extends (...args: any[]) => infer TInstance ? TInstance : TExport
+ *   : unknown;
+ *
+ * Emitted in each file so that services.ts and controllers.ts stand alone, and only when a source
+ * registers its inferred type.
+ *
+ * Resolves the type registered for a service or a controller from the type of its module: the return
+ * type of the default export when it is a factory, the default export itself otherwise. A module
+ * without a default export registers nothing usable at runtime; with strict types enabled, an
+ * unregistered uid resolves to `unknown`, so the helper does the same rather than claiming a
+ * permissive contract for it. A module typed `any` and a default export typed `any` resolve to
+ * `unknown` too: `any` would match the factory branch and register `any`.
+ *
+ * An import that no longer resolves (the source moved after the generation) is an error type, which
+ * no conditional type maps to `unknown`. The generated file is a `.ts` file, so `tsc` reports the
+ * TS2307 there, `skipLibCheck` or not, until the next generation drops the entry.
+ */ const generateInstanceHelperDefinition = (name, comment)=>{
+    const unwrapFactory = factory.createConditionalTypeNode(factory.createTypeReferenceNode('TExport'), factory.createFunctionTypeNode(undefined, [
+        factory.createParameterDeclaration(undefined, factory.createToken(ts.SyntaxKind.DotDotDotToken), 'args', undefined, factory.createArrayTypeNode(factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)))
+    ], factory.createInferTypeNode(factory.createTypeParameterDeclaration(undefined, 'TInstance'))), factory.createTypeReferenceNode('TInstance'), factory.createTypeReferenceNode('TExport'));
+    // 0 extends 1 & TExport: only true when TExport is `any`
+    const guardAny = factory.createConditionalTypeNode(factory.createLiteralTypeNode(factory.createNumericLiteral(0)), factory.createIntersectionTypeNode([
+        factory.createLiteralTypeNode(factory.createNumericLiteral(1)),
+        factory.createTypeReferenceNode('TExport')
+    ]), factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword), unwrapFactory);
+    const unwrapDefaultExport = factory.createConditionalTypeNode(factory.createTypeReferenceNode('TModule'), factory.createTypeLiteralNode([
+        factory.createPropertySignature(undefined, 'default', undefined, factory.createInferTypeNode(factory.createTypeParameterDeclaration(undefined, 'TExport')))
+    ]), guardAny, factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword));
+    return withDocComment(factory.createTypeAliasDeclaration(undefined, factory.createIdentifier(name), [
+        factory.createTypeParameterDeclaration(undefined, 'TModule')
+    ], unwrapDefaultExport), comment);
+};
+/**
+ * type <name><TContract> = 0 extends 1 & TContract ? unknown : TContract;
+ *
+ * Emitted only when at least one source exports a contract: an application without contracts does
+ * not get it.
+ *
+ * A contract typed `any` registers `unknown`, as for an unregistered uid, rather than turning every
+ * lookup of the uid into `any`.
+ *
+ * A contract reference that no longer resolves to a type (the export was renamed after the
+ * generation, or a specifier names a value) is an error type, which no conditional type can map to
+ * `unknown` (an alias instantiated with the error type stays the error type). The generated file is a
+ * `.ts` file, so `tsc` reports the TS2694/TS2749 there, `skipLibCheck` or not. The next generation,
+ * on every `strapi develop` start, registers the source without its contract again.
+ */ const generateContractHelperDefinition = (name, comment)=>withDocComment(factory.createTypeAliasDeclaration(undefined, factory.createIdentifier(name), [
+        factory.createTypeParameterDeclaration(undefined, 'TContract')
+    ], factory.createConditionalTypeNode(factory.createLiteralTypeNode(factory.createNumericLiteral(0)), factory.createIntersectionTypeNode([
+        factory.createLiteralTypeNode(factory.createNumericLiteral(1)),
+        factory.createTypeReferenceNode('TContract')
+    ]), factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword), factory.createTypeReferenceNode('TContract'))), comment);
+/**
+ * declare global {
+ *   namespace Strapi {
+ *     namespace Registries {
+ *       interface <registry> {
+ *         '<uid>': <value>;
+ *       }
+ *       …
+ *     }
+ *   }
+ * }
+ *
+ * The registries are global interfaces, so this augmentation merges with the base declaration and
+ * with the application's own entries, whatever module resolution the application uses. Lookups and
+ * route configs only consult it once the program opts into strict types.
+ */ const generateRegistryExtensionDefinition = (registries)=>{
+    const interfaces = registries.map(({ registry, entries })=>factory.createInterfaceDeclaration(undefined, factory.createIdentifier(registry), undefined, undefined, entries.map(([uid, value])=>factory.createPropertySignature(undefined, factory.createStringLiteral(uid, true), undefined, value))));
+    const namespaceOf = (name, statements)=>factory.createModuleDeclaration(undefined, factory.createIdentifier(name), factory.createModuleBlock(statements), ts.NodeFlags.Namespace);
+    return factory.createModuleDeclaration([
+        factory.createModifier(ts.SyntaxKind.DeclareKeyword)
+    ], factory.createIdentifier('global'), factory.createModuleBlock([
+        namespaceOf(GLOBAL_NAMESPACE, [
+            namespaceOf(REGISTRIES_NAMESPACE, interfaces)
+        ])
+    ]), ts.NodeFlags.GlobalAugmentation);
+};
+/**
+ * export {};
+ *
+ * <helpers>
+ *
+ * declare global { … <registry> … <markers> … }
+ *
+ * The module marker turns the generated file into a module: the global augmentation is only allowed
+ * in one. The helpers come first so that the file stands alone. A marker without uids is not
+ * emitted, so that the output of an application without such uids does not change.
+ */ const emitRegistryDefinitions = async (registry, helpers, sources, toValue, markers = [])=>{
+    const allDefinitions = [
+        // Module marker
+        factory.createExportDeclaration(undefined, false, factory.createNamedExports([])),
+        // Add a newline after the marker
+        factory.createIdentifier('\n'),
+        // Helpers
+        ...helpers,
+        // Add a newline after the helpers
+        factory.createIdentifier('\n'),
+        // Global
+        generateRegistryExtensionDefinition([
+            {
+                registry,
+                entries: sources.map((source)=>[
+                        source.uid,
+                        toValue(source)
+                    ])
+            },
+            ...markers.filter((marker)=>marker.uids.length > 0).map((marker)=>({
+                    registry: marker.registry,
+                    entries: marker.uids.map((uid)=>[
+                            uid,
+                            factory.createLiteralTypeNode(factory.createTrue())
+                        ])
+                }))
+        ])
+    ];
+    return format(emitDefinitions(allDefinitions));
+};
+
+export { collectAppSources, emitRegistryDefinitions, filterRegisteredSources, findTypeExports, generateContractHelperDefinition, generateInstanceHelperDefinition, instanceTypeOf, isInferredSource, isTypedSource, typeofImport, withDocComment };
+//# sourceMappingURL=sources.mjs.map

package/dist/generators/common/sources.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sources.mjs","sources":["../../../src/generators/common/sources.ts"],"sourcesContent":["import path from 'node:path';\nimport fs, { type Dirent } from 'node:fs';\nimport * as ts from 'typescript';\nimport { kebabCase } from 'lodash';\n\nimport { emitDefinitions, format, pathExists } from '../utils';\nimport type { Logger } from '../utils';\nimport { compareCodeUnits } from './compare';\n\n/**\n * Shared by the generators of application modules (services, controllers, policies, middlewares):\n * they find the source files the loaders of @strapi/core register, derive the same uids, and write\n * one global registry each. Each generator keeps what it reads from a module type and which registry\n * it writes.\n */\n\nconst { factory } = ts;\n\nconst GLOBAL_NAMESPACE = 'Strapi';\nconst REGISTRIES_NAMESPACE = 'Registries';\n\n// Ordered by precedence when several files resolve to the same uid\nconst SOURCE_EXTENSIONS = ['.ts', '.js'];\n\nexport type AppModuleSource = {\n  uid: string;\n  file: string;\n  // Extension-less path of the source file, relative to the generated directory\n  specifier: string;\n};\n\n/**\n * Directory of each module kind in an API (src/api/<api>/<kind>), and in src/ for the kinds the\n * loaders also register globally (policies, middlewares)\n */\nexport type AppModuleKind = 'services' | 'controllers' | 'policies' | 'middlewares';\n\n/**\n * Mirror of the API loader's name normalization (@strapi/core, loaders/apis.ts): names already in\n * kebab-case are kept as is, anything else is kebab-cased. Both must agree for the generated uids\n * to match the ones registered at runtime. Global policies and middlewares (loaders/policies.ts,\n * loaders/middlewares.ts) are not normalized.\n */\nconst isKebabCase = (value: string) => /^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/.test(value);\nconst normalizeName = (name: string) => (isKebabCase(name) ? name : kebabCase(name));\n\nconst isSourceFile = (fd: Dirent) =>\n  fd.isFile() && !fd.name.endsWith('.d.ts') && SOURCE_EXTENSIONS.includes(path.extname(fd.name));\n\nconst byExtensionPrecedence = (a: Dirent, b: Dirent) =>\n  SOURCE_EXTENSIONS.indexOf(path.extname(a.name)) - SOURCE_EXTENSIONS.indexOf(path.extname(b.name));\n\nconst toImportSpecifier = (from: string, to: string) => {\n  const specifier = path.relative(from, to).split(path.sep).join('/');\n\n  return specifier.startsWith('.') ? specifier : `./${specifier}`;\n};\n\n/**\n * Add the source files of a directory to `sources`, under the uid returned by `toUID`\n */\nconst collectDirectorySources = async (\n  dir: string,\n  toUID: (basename: string) => string,\n  sources: Map<string, AppModuleSource>,\n  outDir: string,\n  logger: Logger\n) => {\n  if ((await pathExists(dir)) === false) {\n    return;\n  }\n\n  const sourceFDs = (await fs.promises.readdir(dir, { withFileTypes: true }))\n    .filter(isSourceFile)\n    .sort(byExtensionPrecedence);\n\n  for (const sourceFD of sourceFDs) {\n    const basename = path.basename(sourceFD.name, path.extname(sourceFD.name));\n    const uid = toUID(basename);\n    const file = path.join(dir, sourceFD.name);\n\n    if (sources.has(uid)) {\n      logger.warn(`Several source files resolve to ${uid}, ignoring ${file}`);\n      continue;\n    }\n\n    sources.set(uid, {\n      uid,\n      file,\n      specifier: toImportSpecifier(outDir, path.join(dir, basename)),\n    });\n  }\n};\n\n/**\n * Collect the global source files of a kind when `dirs.global` is given (src/<kind>/<name>.{ts,js}\n * → global::<name>), then the ones of every API (src/api/<api>/<kind>/<name>.{ts,js} →\n * api::<api>.<name>). The first file to resolve to a uid wins.\n */\nexport const collectAppSources = async (\n  kind: AppModuleKind,\n  dirs: { global?: string; api: string },\n  outDir: string,\n  logger: Logger\n): Promise<AppModuleSource[]> => {\n  const sources = new Map<string, AppModuleSource>();\n\n  if (dirs.global !== undefined) {\n    await collectDirectorySources(\n      dirs.global,\n      (basename) => `global::${basename}`,\n      sources,\n      outDir,\n      logger\n    );\n  }\n\n  if ((await pathExists(dirs.api)) === true) {\n    const apiFDs = (await fs.promises.readdir(dirs.api, { withFileTypes: true })).filter(\n      (fd) => fd.isDirectory() && !fd.name.startsWith('.')\n    );\n\n    for (const apiFD of apiFDs) {\n      const apiName = normalizeName(apiFD.name);\n\n      await collectDirectorySources(\n        path.join(dirs.api, apiFD.name, kind),\n        (basename) => `api::${apiName}.${normalizeName(basename)}`,\n        sources,\n        outDir,\n        logger\n      );\n    }\n  }\n\n  return Array.from(sources.values());\n};\n\n/**\n * Keep the sources whose uid the running app registered, sorted by uid\n */\nexport const filterRegisteredSources = (\n  sources: AppModuleSource[],\n  registered: Record<string, unknown>,\n  logger: Logger\n) => {\n  const registeredUIDs = new Set(Object.keys(registered));\n\n  return sources\n    .filter((source) => {\n      if (!registeredUIDs.has(source.uid)) {\n        logger.debug(`${source.uid} is not registered, ignoring ${source.file}`);\n        return false;\n      }\n\n      return true;\n    })\n    .sort((a, b) => compareCodeUnits(a.uid, b.uid));\n};\n\n/**\n * Application tsconfigs do not enable `allowJs`, so the import of a JS source does not resolve and is\n * an error type. Unlike `any`, conditional types cannot map it to `unknown`.\n */\nexport const isTypedSource = (source: AppModuleSource) => path.extname(source.file) === '.ts';\n\nconst hasModifier = (statement: ts.Statement, kind: ts.ModifierSyntaxKind) =>\n  ts.canHaveModifiers(statement) &&\n  (ts.getModifiers(statement) ?? []).some((modifier) => modifier.kind === kind);\n\n/**\n * Whether a top-level statement is `export type <name>` or `export interface <name>`\n */\nconst isExportedTypeDeclarationNamed = (\n  statement: ts.Statement,\n  name: string\n): statement is ts.TypeAliasDeclaration | ts.InterfaceDeclaration =>\n  (ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement)) &&\n  statement.name.text === name &&\n  hasModifier(statement, ts.SyntaxKind.ExportKeyword) === true &&\n  hasModifier(statement, ts.SyntaxKind.DefaultKeyword) === false;\n\n/**\n * Whether a type declaration can be referenced without type arguments, as the generated file does\n */\nconst hasDefaultTypeArguments = (statement: ts.TypeAliasDeclaration | ts.InterfaceDeclaration) =>\n  (statement.typeParameters ?? []).every((parameter) => parameter.default !== undefined);\n\n/**\n * Whether a top-level statement exports a type under `name`: `export type <name>`,\n * `export interface <name>`, or an export specifier named `<name>` (`export { <name> }`,\n * `export { type X as <name> }`, `export type { X as <name> } from './x'`).\n *\n * A generic declaration only counts when each of its type parameters has a default: the generated\n * file references it without type arguments.\n *\n * A specifier may name a value rather than a type, or a generic without defaults: its reference in\n * the generated file does not resolve, and `tsc` reports it there.\n * TODO @Nico a specifier of a local declaration could be checked like the declaration itself\n */\nconst exportsTypeNamed = (statement: ts.Statement, name: string) => {\n  if (ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement)) {\n    return (\n      isExportedTypeDeclarationNamed(statement, name) === true &&\n      hasDefaultTypeArguments(statement) === true\n    );\n  }\n\n  if (\n    ts.isExportDeclaration(statement) &&\n    statement.exportClause !== undefined &&\n    ts.isNamedExports(statement.exportClause)\n  ) {\n    return statement.exportClause.elements.some((element) => element.name.text === name);\n  }\n\n  return false;\n};\n\n/**\n * The uids of the TypeScript sources whose module exports a type named `name`, such as a service's\n * `ServiceContract`.\n *\n * Each source is parsed on its own, without a program: type generation runs on every `strapi develop`\n * start, before the compilation, and a program would need the application's tsconfig and its whole\n * dependency graph. Only top-level declarations and export specifiers are read (see\n * `exportsTypeNamed`). `export *` is not followed, and a source that cannot be read is skipped with a\n * warning: both keep the type the source registers without a contract, rather than stopping the\n * generation.\n *\n * JS sources are skipped: their import does not resolve without `allowJs` (see `isTypedSource`).\n */\nexport const findTypeExports = async (\n  sources: AppModuleSource[],\n  name: string,\n  logger: Logger\n): Promise<Set<string>> => {\n  // TODO @Nico A JS source could get a contract from a sibling `<name>.d.ts` that exports it: the\n  // extension-less import of the source resolves to that file without `allowJs`.\n  const typedSources = sources.filter(isTypedSource);\n\n  const verdicts = await Promise.all(\n    typedSources.map(async (source) => {\n      let content: string;\n\n      try {\n        content = await fs.promises.readFile(source.file, 'utf8');\n      } catch (error) {\n        logger.warn(\n          `Could not read ${source.file} to find its ${name} export, typing ${source.uid} without it: ${\n            error instanceof Error ? error.message : String(error)\n          }`\n        );\n        return false;\n      }\n\n      const sourceFile = ts.createSourceFile(\n        source.file,\n        content,\n        ts.ScriptTarget.Latest,\n        false,\n        ts.ScriptKind.TS\n      );\n\n      if (sourceFile.statements.some((statement) => exportsTypeNamed(statement, name)) === true) {\n        return true;\n      }\n\n      if (\n        sourceFile.statements.some(\n          (statement) =>\n            isExportedTypeDeclarationNamed(statement, name) === true &&\n            hasDefaultTypeArguments(statement) === false\n        ) === true\n      ) {\n        logger.warn(\n          `${source.file} exports ${name} with type parameters that have no default, typing ${source.uid} without it`\n        );\n      }\n\n      if (\n        sourceFile.statements.some(\n          (statement) => ts.isExportDeclaration(statement) && statement.exportClause === undefined\n        ) === true\n      ) {\n        logger.debug(`${source.uid}: \\`export *\\` is not followed to find a ${name} export`);\n      }\n\n      return false;\n    })\n  );\n\n  return new Set(typedSources.filter((_, index) => verdicts[index] === true).map(({ uid }) => uid));\n};\n\n/**\n * A type export that replaces the inferred type of the sources that have it, such as a service's\n * `ServiceContract`.\n */\nexport type AppModuleContract = {\n  // Name of the type export\n  exportName: string;\n  // Name of the generated helper that reads it (see `generateContractHelperDefinition`)\n  helper: string;\n  // Uids of the sources whose module exports it (see `findTypeExports`)\n  uids: Set<string>;\n};\n\n/**\n * The type a service or controller source registers:\n * - `<contract helper><import('<source>').<contract export>>` when the module exports the contract;\n * - `<helper><typeof import('<source>')>` otherwise, which infers it from the default export;\n * - `unknown` for a JS source, whose import is an error type without `allowJs` (see `isTypedSource`).\n *\n * The contract does not depend on the default export, so the factory can be checked against its own\n * uid (`Core.ServiceFactory<uid>`). The inferred type does: the generators list those uids in a\n * marker registry (see `isInferredSource`), which the factory types reject.\n */\nexport const instanceTypeOf =\n  (helper: string, logger: Logger, contract?: AppModuleContract) =>\n  (source: AppModuleSource): ts.TypeNode => {\n    if (isTypedSource(source) === false) {\n      logger.debug(`${source.uid} has no TypeScript source, registering it as unknown`);\n      return factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);\n    }\n\n    if (contract !== undefined && contract.uids.has(source.uid) === true) {\n      logger.debug(`${source.uid} exports ${contract.exportName}, registering it`);\n      return factory.createTypeReferenceNode(contract.helper, [\n        importedType(source, contract.exportName),\n      ]);\n    }\n\n    return factory.createTypeReferenceNode(helper, [typeofImport(source)]);\n  };\n\n/**\n * Whether a source registers the type its module provides (see `instanceTypeOf`): a TypeScript\n * source whose module does not export the contract.\n */\nexport const isInferredSource = (contract: AppModuleContract) => (source: AppModuleSource) =>\n  isTypedSource(source) === true && contract.uids.has(source.uid) === false;\n\n/**\n * typeof import('<relative path to the source>')\n */\nexport const typeofImport = (source: AppModuleSource) =>\n  factory.createImportTypeNode(\n    factory.createLiteralTypeNode(factory.createStringLiteral(source.specifier, true)),\n    undefined,\n    undefined,\n    undefined,\n    true\n  );\n\n/**\n * import('<relative path to the source>').<name>\n */\nconst importedType = (source: AppModuleSource, name: string) =>\n  factory.createImportTypeNode(\n    factory.createLiteralTypeNode(factory.createStringLiteral(source.specifier, true)),\n    undefined,\n    factory.createIdentifier(name),\n    undefined,\n    false\n  );\n\nexport const withDocComment = <TNode extends ts.Node>(node: TNode, comment: string) =>\n  ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, comment, true);\n\n/**\n * type <name><TModule> = TModule extends { default: infer TExport }\n *   ? 0 extends 1 & TExport\n *     ? unknown\n *     : TExport extends (...args: any[]) => infer TInstance ? TInstance : TExport\n *   : unknown;\n *\n * Emitted in each file so that services.ts and controllers.ts stand alone, and only when a source\n * registers its inferred type.\n *\n * Resolves the type registered for a service or a controller from the type of its module: the return\n * type of the default export when it is a factory, the default export itself otherwise. A module\n * without a default export registers nothing usable at runtime; with strict types enabled, an\n * unregistered uid resolves to `unknown`, so the helper does the same rather than claiming a\n * permissive contract for it. A module typed `any` and a default export typed `any` resolve to\n * `unknown` too: `any` would match the factory branch and register `any`.\n *\n * An import that no longer resolves (the source moved after the generation) is an error type, which\n * no conditional type maps to `unknown`. The generated file is a `.ts` file, so `tsc` reports the\n * TS2307 there, `skipLibCheck` or not, until the next generation drops the entry.\n */\nexport const generateInstanceHelperDefinition = (name: string, comment: string) => {\n  const unwrapFactory = factory.createConditionalTypeNode(\n    factory.createTypeReferenceNode('TExport'),\n    factory.createFunctionTypeNode(\n      undefined,\n      [\n        factory.createParameterDeclaration(\n          undefined,\n          factory.createToken(ts.SyntaxKind.DotDotDotToken),\n          'args',\n          undefined,\n          factory.createArrayTypeNode(factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword))\n        ),\n      ],\n      factory.createInferTypeNode(factory.createTypeParameterDeclaration(undefined, 'TInstance'))\n    ),\n    factory.createTypeReferenceNode('TInstance'),\n    factory.createTypeReferenceNode('TExport')\n  );\n\n  // 0 extends 1 & TExport: only true when TExport is `any`\n  const guardAny = factory.createConditionalTypeNode(\n    factory.createLiteralTypeNode(factory.createNumericLiteral(0)),\n    factory.createIntersectionTypeNode([\n      factory.createLiteralTypeNode(factory.createNumericLiteral(1)),\n      factory.createTypeReferenceNode('TExport'),\n    ]),\n    factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),\n    unwrapFactory\n  );\n\n  const unwrapDefaultExport = factory.createConditionalTypeNode(\n    factory.createTypeReferenceNode('TModule'),\n    factory.createTypeLiteralNode([\n      factory.createPropertySignature(\n        undefined,\n        'default',\n        undefined,\n        factory.createInferTypeNode(factory.createTypeParameterDeclaration(undefined, 'TExport'))\n      ),\n    ]),\n    guardAny,\n    factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)\n  );\n\n  return withDocComment(\n    factory.createTypeAliasDeclaration(\n      undefined,\n      factory.createIdentifier(name),\n      [factory.createTypeParameterDeclaration(undefined, 'TModule')],\n      unwrapDefaultExport\n    ),\n    comment\n  );\n};\n\n/**\n * type <name><TContract> = 0 extends 1 & TContract ? unknown : TContract;\n *\n * Emitted only when at least one source exports a contract: an application without contracts does\n * not get it.\n *\n * A contract typed `any` registers `unknown`, as for an unregistered uid, rather than turning every\n * lookup of the uid into `any`.\n *\n * A contract reference that no longer resolves to a type (the export was renamed after the\n * generation, or a specifier names a value) is an error type, which no conditional type can map to\n * `unknown` (an alias instantiated with the error type stays the error type). The generated file is a\n * `.ts` file, so `tsc` reports the TS2694/TS2749 there, `skipLibCheck` or not. The next generation,\n * on every `strapi develop` start, registers the source without its contract again.\n */\nexport const generateContractHelperDefinition = (name: string, comment: string) =>\n  withDocComment(\n    factory.createTypeAliasDeclaration(\n      undefined,\n      factory.createIdentifier(name),\n      [factory.createTypeParameterDeclaration(undefined, 'TContract')],\n      factory.createConditionalTypeNode(\n        factory.createLiteralTypeNode(factory.createNumericLiteral(0)),\n        factory.createIntersectionTypeNode([\n          factory.createLiteralTypeNode(factory.createNumericLiteral(1)),\n          factory.createTypeReferenceNode('TContract'),\n        ]),\n        factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),\n        factory.createTypeReferenceNode('TContract')\n      )\n    ),\n    comment\n  );\n\n/**\n * A registry that lists uids without typing them, such as the uids registered with their inferred\n * type. Each uid maps to `true`, which nothing reads: the marker never depends on a source.\n */\nexport type AppModuleMarker = {\n  registry: string;\n  uids: string[];\n};\n\n/**\n * declare global {\n *   namespace Strapi {\n *     namespace Registries {\n *       interface <registry> {\n *         '<uid>': <value>;\n *       }\n *       …\n *     }\n *   }\n * }\n *\n * The registries are global interfaces, so this augmentation merges with the base declaration and\n * with the application's own entries, whatever module resolution the application uses. Lookups and\n * route configs only consult it once the program opts into strict types.\n */\nconst generateRegistryExtensionDefinition = (\n  registries: { registry: string; entries: [uid: string, value: ts.TypeNode][] }[]\n) => {\n  const interfaces = registries.map(({ registry, entries }) =>\n    factory.createInterfaceDeclaration(\n      undefined,\n      factory.createIdentifier(registry),\n      undefined,\n      undefined,\n      entries.map(([uid, value]) =>\n        factory.createPropertySignature(\n          undefined,\n          factory.createStringLiteral(uid, true),\n          undefined,\n          value\n        )\n      )\n    )\n  );\n\n  const namespaceOf = (name: string, statements: ts.Statement[]) =>\n    factory.createModuleDeclaration(\n      undefined,\n      factory.createIdentifier(name),\n      factory.createModuleBlock(statements),\n      ts.NodeFlags.Namespace\n    );\n\n  return factory.createModuleDeclaration(\n    [factory.createModifier(ts.SyntaxKind.DeclareKeyword)],\n    factory.createIdentifier('global'),\n    factory.createModuleBlock([\n      namespaceOf(GLOBAL_NAMESPACE, [namespaceOf(REGISTRIES_NAMESPACE, interfaces)]),\n    ]),\n    ts.NodeFlags.GlobalAugmentation\n  );\n};\n\n/**\n * export {};\n *\n * <helpers>\n *\n * declare global { … <registry> … <markers> … }\n *\n * The module marker turns the generated file into a module: the global augmentation is only allowed\n * in one. The helpers come first so that the file stands alone. A marker without uids is not\n * emitted, so that the output of an application without such uids does not change.\n */\nexport const emitRegistryDefinitions = async (\n  registry: string,\n  helpers: ts.Node[],\n  sources: AppModuleSource[],\n  toValue: (source: AppModuleSource) => ts.TypeNode,\n  markers: AppModuleMarker[] = []\n) => {\n  const allDefinitions = [\n    // Module marker\n    factory.createExportDeclaration(undefined, false, factory.createNamedExports([])),\n\n    // Add a newline after the marker\n    factory.createIdentifier('\\n'),\n\n    // Helpers\n    ...helpers,\n\n    // Add a newline after the helpers\n    factory.createIdentifier('\\n'),\n\n    // Global\n    generateRegistryExtensionDefinition([\n      {\n        registry,\n        entries: sources.map((source): [string, ts.TypeNode] => [source.uid, toValue(source)]),\n      },\n      ...markers\n        .filter((marker) => marker.uids.length > 0)\n        .map((marker) => ({\n          registry: marker.registry,\n          entries: marker.uids.map((uid): [string, ts.TypeNode] => [\n            uid,\n            factory.createLiteralTypeNode(factory.createTrue()),\n          ]),\n        })),\n    ]),\n  ];\n\n  return format(emitDefinitions(allDefinitions));\n};\n"],"names":["factory","ts","GLOBAL_NAMESPACE","REGISTRIES_NAMESPACE","SOURCE_EXTENSIONS","isKebabCase","value","test","normalizeName","name","kebabCase","isSourceFile","fd","isFile","endsWith","includes","path","extname","byExtensionPrecedence","a","b","indexOf","toImportSpecifier","from","to","specifier","relative","split","sep","join","startsWith","collectDirectorySources","dir","toUID","sources","outDir","logger","pathExists","sourceFDs","fs","promises","readdir","withFileTypes","filter","sort","sourceFD","basename","uid","file","has","warn","set","collectAppSources","kind","dirs","Map","global","undefined","api","apiFDs","isDirectory","apiFD","apiName","Array","values","filterRegisteredSources","registered","registeredUIDs","Set","Object","keys","source","debug","compareCodeUnits","isTypedSource","hasModifier","statement","canHaveModifiers","getModifiers","some","modifier","isExportedTypeDeclarationNamed","isTypeAliasDeclaration","isInterfaceDeclaration","text","SyntaxKind","ExportKeyword","DefaultKeyword","hasDefaultTypeArguments","typeParameters","every","parameter","default","exportsTypeNamed","isExportDeclaration","exportClause","isNamedExports","elements","element","findTypeExports","typedSources","verdicts","Promise","all","map","content","readFile","error","Error","message","String","sourceFile","createSourceFile","ScriptTarget","Latest","ScriptKind","TS","statements","_","index","instanceTypeOf","helper","contract","createKeywordTypeNode","UnknownKeyword","uids","exportName","createTypeReferenceNode","importedType","typeofImport","isInferredSource","createImportTypeNode","createLiteralTypeNode","createStringLiteral","createIdentifier","withDocComment","node","comment","addSyntheticLeadingComment","MultiLineCommentTrivia","generateInstanceHelperDefinition","unwrapFactory","createConditionalTypeNode","createFunctionTypeNode","createParameterDeclaration","createToken","DotDotDotToken","createArrayTypeNode","AnyKeyword","createInferTypeNode","createTypeParameterDeclaration","guardAny","createNumericLiteral","createIntersectionTypeNode","unwrapDefaultExport","createTypeLiteralNode","createPropertySignature","createTypeAliasDeclaration","generateContractHelperDefinition","generateRegistryExtensionDefinition","registries","interfaces","registry","entries","createInterfaceDeclaration","namespaceOf","createModuleDeclaration","createModuleBlock","NodeFlags","Namespace","createModifier","DeclareKeyword","GlobalAugmentation","emitRegistryDefinitions","helpers","toValue","markers","allDefinitions","createExportDeclaration","createNamedExports","marker","length","createTrue","format","emitDefinitions"],"mappings":";;;;;;;AASA;;;;;AAKC,IAED,MAAM,EAAEA,OAAO,EAAE,GAAGC,EAAAA;AAEpB,MAAMC,gBAAAA,GAAmB,QAAA;AACzB,MAAMC,oBAAAA,GAAuB,YAAA;AAE7B;AACA,MAAMC,iBAAAA,GAAoB;AAAC,IAAA,KAAA;AAAO,IAAA;AAAM,CAAA;AAexC;;;;;AAKC,IACD,MAAMC,WAAAA,GAAc,CAACC,KAAAA,GAAkB,iCAAA,CAAkCC,IAAI,CAACD,KAAAA,CAAAA;AAC9E,MAAME,gBAAgB,CAACC,IAAAA,GAAkBJ,WAAAA,CAAYI,IAAAA,CAAAA,GAAQA,OAAOC,SAAAA,CAAUD,IAAAA,CAAAA;AAE9E,MAAME,YAAAA,GAAe,CAACC,EAAAA,GACpBA,EAAAA,CAAGC,MAAM,EAAA,IAAM,CAACD,GAAGH,IAAI,CAACK,QAAQ,CAAC,OAAA,CAAA,IAAYV,kBAAkBW,QAAQ,CAACC,KAAKC,OAAO,CAACL,GAAGH,IAAI,CAAA,CAAA;AAE9F,MAAMS,qBAAAA,GAAwB,CAACC,CAAAA,EAAWC,CAAAA,GACxChB,kBAAkBiB,OAAO,CAACL,KAAKC,OAAO,CAACE,EAAEV,IAAI,CAAA,CAAA,GAAKL,kBAAkBiB,OAAO,CAACL,KAAKC,OAAO,CAACG,EAAEX,IAAI,CAAA,CAAA;AAEjG,MAAMa,iBAAAA,GAAoB,CAACC,IAAAA,EAAcC,EAAAA,GAAAA;AACvC,IAAA,MAAMC,SAAAA,GAAYT,IAAAA,CAAKU,QAAQ,CAACH,IAAAA,EAAMC,EAAAA,CAAAA,CAAIG,KAAK,CAACX,IAAAA,CAAKY,GAAG,CAAA,CAAEC,IAAI,CAAC,GAAA,CAAA;IAE/D,OAAOJ,SAAAA,CAAUK,UAAU,CAAC,GAAA,CAAA,GAAOL,YAAY,CAAC,EAAE,EAAEA,SAAAA,CAAAA,CAAW;AACjE,CAAA;AAEA;;AAEC,IACD,MAAMM,uBAAAA,GAA0B,OAC9BC,GAAAA,EACAC,KAAAA,EACAC,SACAC,MAAAA,EACAC,MAAAA,GAAAA;AAEA,IAAA,IAAI,MAAOC,UAAAA,CAAWL,GAAAA,CAAAA,KAAU,KAAA,EAAO;AACrC,QAAA;AACF,IAAA;IAEA,MAAMM,SAAAA,GAAY,CAAC,MAAMC,GAAGC,QAAQ,CAACC,OAAO,CAACT,GAAAA,EAAK;QAAEU,aAAAA,EAAe;AAAK,KAAA,CAAC,EACtEC,MAAM,CAAChC,YAAAA,CAAAA,CACPiC,IAAI,CAAC1B,qBAAAA,CAAAA;IAER,KAAK,MAAM2B,YAAYP,SAAAA,CAAW;QAChC,MAAMQ,QAAAA,GAAW9B,IAAAA,CAAK8B,QAAQ,CAACD,QAAAA,CAASpC,IAAI,EAAEO,IAAAA,CAAKC,OAAO,CAAC4B,QAAAA,CAASpC,IAAI,CAAA,CAAA;AACxE,QAAA,MAAMsC,MAAMd,KAAAA,CAAMa,QAAAA,CAAAA;AAClB,QAAA,MAAME,OAAOhC,IAAAA,CAAKa,IAAI,CAACG,GAAAA,EAAKa,SAASpC,IAAI,CAAA;QAEzC,IAAIyB,OAAAA,CAAQe,GAAG,CAACF,GAAAA,CAAAA,EAAM;YACpBX,MAAAA,CAAOc,IAAI,CAAC,CAAC,gCAAgC,EAAEH,GAAAA,CAAI,WAAW,EAAEC,IAAAA,CAAAA,CAAM,CAAA;AACtE,YAAA;AACF,QAAA;QAEAd,OAAAA,CAAQiB,GAAG,CAACJ,GAAAA,EAAK;AACfA,YAAAA,GAAAA;AACAC,YAAAA,IAAAA;AACAvB,YAAAA,SAAAA,EAAWH,iBAAAA,CAAkBa,MAAAA,EAAQnB,IAAAA,CAAKa,IAAI,CAACG,GAAAA,EAAKc,QAAAA,CAAAA;AACtD,SAAA,CAAA;AACF,IAAA;AACF,CAAA;AAEA;;;;AAIC,IACM,MAAMM,iBAAAA,GAAoB,OAC/BC,IAAAA,EACAC,MACAnB,MAAAA,EACAC,MAAAA,GAAAA;AAEA,IAAA,MAAMF,UAAU,IAAIqB,GAAAA,EAAAA;IAEpB,IAAID,IAAAA,CAAKE,MAAM,KAAKC,SAAAA,EAAW;AAC7B,QAAA,MAAM1B,uBAAAA,CACJuB,IAAAA,CAAKE,MAAM,EACX,CAACV,QAAAA,GAAa,CAAC,QAAQ,EAAEA,QAAAA,CAAAA,CAAU,EACnCZ,OAAAA,EACAC,MAAAA,EACAC,MAAAA,CAAAA;AAEJ,IAAA;AAEA,IAAA,IAAI,MAAOC,UAAAA,CAAWiB,IAAAA,CAAKI,GAAG,MAAO,IAAA,EAAM;QACzC,MAAMC,MAAAA,GAAS,CAAC,MAAMpB,EAAAA,CAAGC,QAAQ,CAACC,OAAO,CAACa,IAAAA,CAAKI,GAAG,EAAE;YAAEhB,aAAAA,EAAe;AAAK,SAAA,CAAC,EAAGC,MAAM,CAClF,CAAC/B,EAAAA,GAAOA,EAAAA,CAAGgD,WAAW,EAAA,IAAM,CAAChD,EAAAA,CAAGH,IAAI,CAACqB,UAAU,CAAC,GAAA,CAAA,CAAA;QAGlD,KAAK,MAAM+B,SAASF,MAAAA,CAAQ;YAC1B,MAAMG,OAAAA,GAAUtD,aAAAA,CAAcqD,KAAAA,CAAMpD,IAAI,CAAA;YAExC,MAAMsB,uBAAAA,CACJf,KAAKa,IAAI,CAACyB,KAAKI,GAAG,EAAEG,KAAAA,CAAMpD,IAAI,EAAE4C,IAAAA,CAAAA,EAChC,CAACP,QAAAA,GAAa,CAAC,KAAK,EAAEgB,OAAAA,CAAQ,CAAC,EAAEtD,aAAAA,CAAcsC,QAAAA,CAAAA,CAAAA,CAAW,EAC1DZ,OAAAA,EACAC,MAAAA,EACAC,MAAAA,CAAAA;AAEJ,QAAA;AACF,IAAA;AAEA,IAAA,OAAO2B,KAAAA,CAAMxC,IAAI,CAACW,OAAAA,CAAQ8B,MAAM,EAAA,CAAA;AAClC;AAEA;;AAEC,IACM,MAAMC,uBAAAA,GAA0B,CACrC/B,SACAgC,UAAAA,EACA9B,MAAAA,GAAAA;AAEA,IAAA,MAAM+B,cAAAA,GAAiB,IAAIC,GAAAA,CAAIC,MAAAA,CAAOC,IAAI,CAACJ,UAAAA,CAAAA,CAAAA;IAE3C,OAAOhC,OAAAA,CACJS,MAAM,CAAC,CAAC4B,MAAAA,GAAAA;AACP,QAAA,IAAI,CAACJ,cAAAA,CAAelB,GAAG,CAACsB,MAAAA,CAAOxB,GAAG,CAAA,EAAG;YACnCX,MAAAA,CAAOoC,KAAK,CAAC,CAAA,EAAGD,MAAAA,CAAOxB,GAAG,CAAC,6BAA6B,EAAEwB,MAAAA,CAAOvB,IAAI,CAAA,CAAE,CAAA;YACvE,OAAO,KAAA;AACT,QAAA;QAEA,OAAO,IAAA;IACT,CAAA,CAAA,CACCJ,IAAI,CAAC,CAACzB,CAAAA,EAAGC,CAAAA,GAAMqD,iBAAiBtD,CAAAA,CAAE4B,GAAG,EAAE3B,CAAAA,CAAE2B,GAAG,CAAA,CAAA;AACjD;AAEA;;;IAIO,MAAM2B,aAAAA,GAAgB,CAACH,MAAAA,GAA4BvD,IAAAA,CAAKC,OAAO,CAACsD,MAAAA,CAAOvB,IAAI,CAAA,KAAM;AAExF,MAAM2B,WAAAA,GAAc,CAACC,SAAAA,EAAyBvB,IAAAA,GAC5CpD,GAAG4E,gBAAgB,CAACD,SAAAA,CAAAA,IACnB3E,CAAAA,EAAAA,CAAG6E,YAAY,CAACF,SAAAA,CAAAA,IAAc,EAAC,EAAGG,IAAI,CAAC,CAACC,QAAAA,GAAaA,QAAAA,CAAS3B,IAAI,KAAKA,IAAAA,CAAAA;AAE1E;;AAEC,IACD,MAAM4B,8BAAAA,GAAiC,CACrCL,SAAAA,EACAnE,IAAAA,GAEA,CAACR,EAAAA,CAAGiF,sBAAsB,CAACN,cAAc3E,EAAAA,CAAGkF,sBAAsB,CAACP,SAAAA,CAAS,KAC5EA,SAAAA,CAAUnE,IAAI,CAAC2E,IAAI,KAAK3E,IAAAA,IACxBkE,WAAAA,CAAYC,SAAAA,EAAW3E,EAAAA,CAAGoF,UAAU,CAACC,aAAa,CAAA,KAAM,IAAA,IACxDX,YAAYC,SAAAA,EAAW3E,EAAAA,CAAGoF,UAAU,CAACE,cAAc,CAAA,KAAM,KAAA;AAE3D;;AAEC,IACD,MAAMC,uBAAAA,GAA0B,CAACZ,YAC/B,CAACA,UAAUa,cAAc,IAAI,EAAC,EAAGC,KAAK,CAAC,CAACC,SAAAA,GAAcA,SAAAA,CAAUC,OAAO,KAAKnC,SAAAA,CAAAA;AAE9E;;;;;;;;;;;IAYA,MAAMoC,gBAAAA,GAAmB,CAACjB,SAAAA,EAAyBnE,IAAAA,GAAAA;AACjD,IAAA,IAAIR,GAAGiF,sBAAsB,CAACN,cAAc3E,EAAAA,CAAGkF,sBAAsB,CAACP,SAAAA,CAAAA,EAAY;AAChF,QAAA,OACEK,8BAAAA,CAA+BL,SAAAA,EAAWnE,IAAAA,CAAAA,KAAU,IAAA,IACpD+E,wBAAwBZ,SAAAA,CAAAA,KAAe,IAAA;AAE3C,IAAA;AAEA,IAAA,IACE3E,EAAAA,CAAG6F,mBAAmB,CAAClB,SAAAA,CAAAA,IACvBA,SAAAA,CAAUmB,YAAY,KAAKtC,SAAAA,IAC3BxD,EAAAA,CAAG+F,cAAc,CAACpB,SAAAA,CAAUmB,YAAY,CAAA,EACxC;AACA,QAAA,OAAOnB,SAAAA,CAAUmB,YAAY,CAACE,QAAQ,CAAClB,IAAI,CAAC,CAACmB,OAAAA,GAAYA,OAAAA,CAAQzF,IAAI,CAAC2E,IAAI,KAAK3E,IAAAA,CAAAA;AACjF,IAAA;IAEA,OAAO,KAAA;AACT,CAAA;AAEA;;;;;;;;;;;;AAYC,IACM,MAAM0F,eAAAA,GAAkB,OAC7BjE,SACAzB,IAAAA,EACA2B,MAAAA,GAAAA;;;IAIA,MAAMgE,YAAAA,GAAelE,OAAAA,CAAQS,MAAM,CAAC+B,aAAAA,CAAAA;IAEpC,MAAM2B,QAAAA,GAAW,MAAMC,OAAAA,CAAQC,GAAG,CAChCH,YAAAA,CAAaI,GAAG,CAAC,OAAOjC,MAAAA,GAAAA;QACtB,IAAIkC,OAAAA;QAEJ,IAAI;YACFA,OAAAA,GAAU,MAAMlE,GAAGC,QAAQ,CAACkE,QAAQ,CAACnC,MAAAA,CAAOvB,IAAI,EAAE,MAAA,CAAA;AACpD,QAAA,CAAA,CAAE,OAAO2D,KAAAA,EAAO;YACdvE,MAAAA,CAAOc,IAAI,CACT,CAAC,eAAe,EAAEqB,OAAOvB,IAAI,CAAC,aAAa,EAAEvC,IAAAA,CAAK,gBAAgB,EAAE8D,MAAAA,CAAOxB,GAAG,CAAC,aAAa,EAC1F4D,KAAAA,YAAiBC,QAAQD,KAAAA,CAAME,OAAO,GAAGC,MAAAA,CAAOH,KAAAA,CAAAA,CAAAA,CAChD,CAAA;YAEJ,OAAO,KAAA;AACT,QAAA;AAEA,QAAA,MAAMI,aAAa9G,EAAAA,CAAG+G,gBAAgB,CACpCzC,MAAAA,CAAOvB,IAAI,EACXyD,OAAAA,EACAxG,EAAAA,CAAGgH,YAAY,CAACC,MAAM,EACtB,OACAjH,EAAAA,CAAGkH,UAAU,CAACC,EAAE,CAAA;QAGlB,IAAIL,UAAAA,CAAWM,UAAU,CAACtC,IAAI,CAAC,CAACH,SAAAA,GAAciB,gBAAAA,CAAiBjB,SAAAA,EAAWnE,IAAAA,CAAAA,CAAAA,KAAW,IAAA,EAAM;YACzF,OAAO,IAAA;AACT,QAAA;AAEA,QAAA,IACEsG,UAAAA,CAAWM,UAAU,CAACtC,IAAI,CACxB,CAACH,SAAAA,GACCK,8BAAAA,CAA+BL,SAAAA,EAAWnE,IAAAA,CAAAA,KAAU,IAAA,IACpD+E,uBAAAA,CAAwBZ,SAAAA,CAAAA,KAAe,WACrC,IAAA,EACN;AACAxC,YAAAA,MAAAA,CAAOc,IAAI,CACT,CAAA,EAAGqB,MAAAA,CAAOvB,IAAI,CAAC,SAAS,EAAEvC,IAAAA,CAAK,mDAAmD,EAAE8D,MAAAA,CAAOxB,GAAG,CAAC,WAAW,CAAC,CAAA;AAE/G,QAAA;AAEA,QAAA,IACEgE,UAAAA,CAAWM,UAAU,CAACtC,IAAI,CACxB,CAACH,SAAAA,GAAc3E,EAAAA,CAAG6F,mBAAmB,CAAClB,SAAAA,CAAAA,IAAcA,SAAAA,CAAUmB,YAAY,KAAKtC,eAC3E,IAAA,EACN;YACArB,MAAAA,CAAOoC,KAAK,CAAC,CAAA,EAAGD,MAAAA,CAAOxB,GAAG,CAAC,yCAAyC,EAAEtC,IAAAA,CAAK,OAAO,CAAC,CAAA;AACrF,QAAA;QAEA,OAAO,KAAA;AACT,IAAA,CAAA,CAAA,CAAA;AAGF,IAAA,OAAO,IAAI2D,GAAAA,CAAIgC,YAAAA,CAAazD,MAAM,CAAC,CAAC2E,GAAGC,KAAAA,GAAUlB,QAAQ,CAACkB,KAAAA,CAAM,KAAK,MAAMf,GAAG,CAAC,CAAC,EAAEzD,GAAG,EAAE,GAAKA,GAAAA,CAAAA,CAAAA;AAC9F;AAeA;;;;;;;;;AASC,IACM,MAAMyE,cAAAA,GACX,CAACC,MAAAA,EAAgBrF,MAAAA,EAAgBsF,WACjC,CAACnD,MAAAA,GAAAA;QACC,IAAIG,aAAAA,CAAcH,YAAY,KAAA,EAAO;AACnCnC,YAAAA,MAAAA,CAAOoC,KAAK,CAAC,CAAA,EAAGD,OAAOxB,GAAG,CAAC,oDAAoD,CAAC,CAAA;AAChF,YAAA,OAAO/C,QAAQ2H,qBAAqB,CAAC1H,EAAAA,CAAGoF,UAAU,CAACuC,cAAc,CAAA;AACnE,QAAA;QAEA,IAAIF,QAAAA,KAAajE,SAAAA,IAAaiE,QAAAA,CAASG,IAAI,CAAC5E,GAAG,CAACsB,MAAAA,CAAOxB,GAAG,CAAA,KAAM,IAAA,EAAM;AACpEX,YAAAA,MAAAA,CAAOoC,KAAK,CAAC,CAAA,EAAGD,MAAAA,CAAOxB,GAAG,CAAC,SAAS,EAAE2E,QAAAA,CAASI,UAAU,CAAC,gBAAgB,CAAC,CAAA;AAC3E,YAAA,OAAO9H,OAAAA,CAAQ+H,uBAAuB,CAACL,QAAAA,CAASD,MAAM,EAAE;gBACtDO,YAAAA,CAAazD,MAAAA,EAAQmD,SAASI,UAAU;AACzC,aAAA,CAAA;AACH,QAAA;QAEA,OAAO9H,OAAAA,CAAQ+H,uBAAuB,CAACN,MAAAA,EAAQ;YAACQ,YAAAA,CAAa1D,MAAAA;AAAQ,SAAA,CAAA;IACvE;AAEF;;;AAGC,IACM,MAAM2D,gBAAAA,GAAmB,CAACR,QAAAA,GAAgC,CAACnD,SAChEG,aAAAA,CAAcH,MAAAA,CAAAA,KAAY,IAAA,IAAQmD,QAAAA,CAASG,IAAI,CAAC5E,GAAG,CAACsB,MAAAA,CAAOxB,GAAG,MAAM;AAEtE;;UAGakF,YAAAA,GAAe,CAAC1D,SAC3BvE,OAAAA,CAAQmI,oBAAoB,CAC1BnI,OAAAA,CAAQoI,qBAAqB,CAACpI,OAAAA,CAAQqI,mBAAmB,CAAC9D,MAAAA,CAAO9C,SAAS,EAAE,IAAA,CAAA,CAAA,EAC5EgC,SAAAA,EACAA,SAAAA,EACAA,SAAAA,EACA,IAAA;AAGJ;;IAGA,MAAMuE,eAAe,CAACzD,MAAAA,EAAyB9D,OAC7CT,OAAAA,CAAQmI,oBAAoB,CAC1BnI,OAAAA,CAAQoI,qBAAqB,CAACpI,QAAQqI,mBAAmB,CAAC9D,MAAAA,CAAO9C,SAAS,EAAE,IAAA,CAAA,CAAA,EAC5EgC,WACAzD,OAAAA,CAAQsI,gBAAgB,CAAC7H,IAAAA,CAAAA,EACzBgD,SAAAA,EACA,KAAA,CAAA;AAGG,MAAM8E,cAAAA,GAAiB,CAAwBC,IAAAA,EAAaC,UACjExI,EAAAA,CAAGyI,0BAA0B,CAACF,IAAAA,EAAMvI,GAAGoF,UAAU,CAACsD,sBAAsB,EAAEF,SAAS,IAAA;AAErF;;;;;;;;;;;;;;;;;;;;AAoBC,IACM,MAAMG,gCAAAA,GAAmC,CAACnI,IAAAA,EAAcgI,OAAAA,GAAAA;IAC7D,MAAMI,aAAAA,GAAgB7I,OAAAA,CAAQ8I,yBAAyB,CACrD9I,OAAAA,CAAQ+H,uBAAuB,CAAC,SAAA,CAAA,EAChC/H,OAAAA,CAAQ+I,sBAAsB,CAC5BtF,SAAAA,EACA;QACEzD,OAAAA,CAAQgJ,0BAA0B,CAChCvF,SAAAA,EACAzD,OAAAA,CAAQiJ,WAAW,CAAChJ,EAAAA,CAAGoF,UAAU,CAAC6D,cAAc,CAAA,EAChD,QACAzF,SAAAA,EACAzD,OAAAA,CAAQmJ,mBAAmB,CAACnJ,OAAAA,CAAQ2H,qBAAqB,CAAC1H,EAAAA,CAAGoF,UAAU,CAAC+D,UAAU,CAAA,CAAA;AAErF,KAAA,EACDpJ,OAAAA,CAAQqJ,mBAAmB,CAACrJ,OAAAA,CAAQsJ,8BAA8B,CAAC7F,SAAAA,EAAW,WAAA,CAAA,CAAA,CAAA,EAEhFzD,OAAAA,CAAQ+H,uBAAuB,CAAC,WAAA,CAAA,EAChC/H,OAAAA,CAAQ+H,uBAAuB,CAAC,SAAA,CAAA,CAAA;;AAIlC,IAAA,MAAMwB,QAAAA,GAAWvJ,OAAAA,CAAQ8I,yBAAyB,CAChD9I,OAAAA,CAAQoI,qBAAqB,CAACpI,OAAAA,CAAQwJ,oBAAoB,CAAC,CAAA,CAAA,CAAA,EAC3DxJ,OAAAA,CAAQyJ,0BAA0B,CAAC;AACjCzJ,QAAAA,OAAAA,CAAQoI,qBAAqB,CAACpI,OAAAA,CAAQwJ,oBAAoB,CAAC,CAAA,CAAA,CAAA;AAC3DxJ,QAAAA,OAAAA,CAAQ+H,uBAAuB,CAAC,SAAA;AACjC,KAAA,CAAA,EACD/H,QAAQ2H,qBAAqB,CAAC1H,GAAGoF,UAAU,CAACuC,cAAc,CAAA,EAC1DiB,aAAAA,CAAAA;IAGF,MAAMa,mBAAAA,GAAsB1J,OAAAA,CAAQ8I,yBAAyB,CAC3D9I,OAAAA,CAAQ+H,uBAAuB,CAAC,SAAA,CAAA,EAChC/H,OAAAA,CAAQ2J,qBAAqB,CAAC;QAC5B3J,OAAAA,CAAQ4J,uBAAuB,CAC7BnG,SAAAA,EACA,SAAA,EACAA,SAAAA,EACAzD,OAAAA,CAAQqJ,mBAAmB,CAACrJ,OAAAA,CAAQsJ,8BAA8B,CAAC7F,SAAAA,EAAW,SAAA,CAAA,CAAA;AAEjF,KAAA,CAAA,EACD8F,UACAvJ,OAAAA,CAAQ2H,qBAAqB,CAAC1H,EAAAA,CAAGoF,UAAU,CAACuC,cAAc,CAAA,CAAA;IAG5D,OAAOW,cAAAA,CACLvI,QAAQ6J,0BAA0B,CAChCpG,WACAzD,OAAAA,CAAQsI,gBAAgB,CAAC7H,IAAAA,CAAAA,EACzB;QAACT,OAAAA,CAAQsJ,8BAA8B,CAAC7F,SAAAA,EAAW,SAAA;AAAW,KAAA,EAC9DiG,mBAAAA,CAAAA,EAEFjB,OAAAA,CAAAA;AAEJ;AAEA;;;;;;;;;;;;;;AAcC,IACM,MAAMqB,gCAAAA,GAAmC,CAACrJ,MAAcgI,OAAAA,GAC7DF,cAAAA,CACEvI,OAAAA,CAAQ6J,0BAA0B,CAChCpG,SAAAA,EACAzD,OAAAA,CAAQsI,gBAAgB,CAAC7H,IAAAA,CAAAA,EACzB;QAACT,OAAAA,CAAQsJ,8BAA8B,CAAC7F,SAAAA,EAAW,WAAA;AAAa,KAAA,EAChEzD,OAAAA,CAAQ8I,yBAAyB,CAC/B9I,OAAAA,CAAQoI,qBAAqB,CAACpI,OAAAA,CAAQwJ,oBAAoB,CAAC,CAAA,CAAA,CAAA,EAC3DxJ,OAAAA,CAAQyJ,0BAA0B,CAAC;AACjCzJ,QAAAA,OAAAA,CAAQoI,qBAAqB,CAACpI,OAAAA,CAAQwJ,oBAAoB,CAAC,CAAA,CAAA,CAAA;AAC3DxJ,QAAAA,OAAAA,CAAQ+H,uBAAuB,CAAC,WAAA;AACjC,KAAA,CAAA,EACD/H,OAAAA,CAAQ2H,qBAAqB,CAAC1H,EAAAA,CAAGoF,UAAU,CAACuC,cAAc,CAAA,EAC1D5H,OAAAA,CAAQ+H,uBAAuB,CAAC,WAAA,CAAA,CAAA,CAAA,EAGpCU,OAAAA;AAYJ;;;;;;;;;;;;;;;IAgBA,MAAMsB,sCAAsC,CAC1CC,UAAAA,GAAAA;AAEA,IAAA,MAAMC,aAAaD,UAAAA,CAAWxD,GAAG,CAAC,CAAC,EAAE0D,QAAQ,EAAEC,OAAO,EAAE,GACtDnK,OAAAA,CAAQoK,0BAA0B,CAChC3G,SAAAA,EACAzD,OAAAA,CAAQsI,gBAAgB,CAAC4B,QAAAA,CAAAA,EACzBzG,SAAAA,EACAA,SAAAA,EACA0G,QAAQ3D,GAAG,CAAC,CAAC,CAACzD,KAAKzC,KAAAA,CAAM,GACvBN,OAAAA,CAAQ4J,uBAAuB,CAC7BnG,SAAAA,EACAzD,OAAAA,CAAQqI,mBAAmB,CAACtF,GAAAA,EAAK,OACjCU,SAAAA,EACAnD,KAAAA,CAAAA,CAAAA,CAAAA,CAAAA;AAMR,IAAA,MAAM+J,cAAc,CAAC5J,IAAAA,EAAc4G,aACjCrH,OAAAA,CAAQsK,uBAAuB,CAC7B7G,SAAAA,EACAzD,OAAAA,CAAQsI,gBAAgB,CAAC7H,IAAAA,CAAAA,EACzBT,QAAQuK,iBAAiB,CAAClD,aAC1BpH,EAAAA,CAAGuK,SAAS,CAACC,SAAS,CAAA;IAG1B,OAAOzK,OAAAA,CAAQsK,uBAAuB,CACpC;AAACtK,QAAAA,OAAAA,CAAQ0K,cAAc,CAACzK,EAAAA,CAAGoF,UAAU,CAACsF,cAAc;AAAE,KAAA,EACtD3K,QAAQsI,gBAAgB,CAAC,QAAA,CAAA,EACzBtI,OAAAA,CAAQuK,iBAAiB,CAAC;AACxBF,QAAAA,WAAAA,CAAYnK,gBAAAA,EAAkB;AAACmK,YAAAA,WAAAA,CAAYlK,oBAAAA,EAAsB8J,UAAAA;AAAY,SAAA;KAC9E,CAAA,EACDhK,EAAAA,CAAGuK,SAAS,CAACI,kBAAkB,CAAA;AAEnC,CAAA;AAEA;;;;;;;;;;UAWaC,uBAAAA,GAA0B,OACrCX,UACAY,OAAAA,EACA5I,OAAAA,EACA6I,OAAAA,EACAC,OAAAA,GAA6B,EAAE,GAAA;AAE/B,IAAA,MAAMC,cAAAA,GAAiB;;AAErBjL,QAAAA,OAAAA,CAAQkL,uBAAuB,CAACzH,SAAAA,EAAW,OAAOzD,OAAAA,CAAQmL,kBAAkB,CAAC,EAAE,CAAA,CAAA;;AAG/EnL,QAAAA,OAAAA,CAAQsI,gBAAgB,CAAC,IAAA,CAAA;;AAGtBwC,QAAAA,GAAAA,OAAAA;;AAGH9K,QAAAA,OAAAA,CAAQsI,gBAAgB,CAAC,IAAA,CAAA;;QAGzByB,mCAAAA,CAAoC;AAClC,YAAA;AACEG,gBAAAA,QAAAA;AACAC,gBAAAA,OAAAA,EAASjI,OAAAA,CAAQsE,GAAG,CAAC,CAACjC,MAAAA,GAAkC;AAACA,wBAAAA,MAAAA,CAAOxB,GAAG;wBAAEgI,OAAAA,CAAQxG,MAAAA;AAAQ,qBAAA;AACvF,aAAA;AACGyG,YAAAA,GAAAA,OAAAA,CACArI,MAAM,CAAC,CAACyI,MAAAA,GAAWA,OAAOvD,IAAI,CAACwD,MAAM,GAAG,CAAA,CAAA,CACxC7E,GAAG,CAAC,CAAC4E,UAAY;AAChBlB,oBAAAA,QAAAA,EAAUkB,OAAOlB,QAAQ;AACzBC,oBAAAA,OAAAA,EAASiB,OAAOvD,IAAI,CAACrB,GAAG,CAAC,CAACzD,GAAAA,GAA+B;AACvDA,4BAAAA,GAAAA;4BACA/C,OAAAA,CAAQoI,qBAAqB,CAACpI,OAAAA,CAAQsL,UAAU,EAAA;AACjD,yBAAA;iBACH,CAAA;AACH,SAAA;AACF,KAAA;AAED,IAAA,OAAOC,OAAOC,eAAAA,CAAgBP,cAAAA,CAAAA,CAAAA;AAChC;;;;"}

package/dist/generators/components/index.d.ts

@@ -0,0 +1,9 @@
+import type { GeneratorOptions } from '../utils';
+/**
+ * Generate type definitions for Strapi Components
+ */
+export declare const generateComponentsDefinitions: (options?: GeneratorOptions) => Promise<{
+    output: string;
+    stats: {};
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generators/components/index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AASjD;;GAEG;AACH,eAAO,MAAM,6BAA6B,GACxC,UAAS,gBAAyC;;;EAyDnD,CAAC"}

package/dist/generators/components/index.js

@@ -0,0 +1,84 @@
+'use strict';
+
+var ts = require('typescript');
+var _ = require('lodash');
+var schema = require('../common/models/schema.js');
+var imports = require('../common/imports.js');
+var interfaceNames = require('../common/interface-names.js');
+var utils = require('../utils.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
+
+const { factory } = ts__namespace;
+const NO_COMPONENT_PLACEHOLDER_COMMENT = `/*
+ * The app doesn't have any components yet.
+ */
+`;
+/**
+ * Generate type definitions for Strapi Components
+ */ const generateComponentsDefinitions = async (options = {})=>{
+    const { strapi, strict = false } = options;
+    const { components } = strapi;
+    const schemas = _.sortBy(Object.values(components ?? {}), 'uid');
+    const interfaceNames$1 = interfaceNames.resolveInterfaceNames(schemas.map(({ uid })=>uid), options.logger, {
+        strict
+    });
+    const componentsDefinitions = schemas.map((component)=>({
+            uid: component.uid,
+            definition: schema.generateSchemaDefinition(component, interfaceNames$1.get(component.uid), {
+                strict
+            })
+        }));
+    options.logger.debug(`Found ${componentsDefinitions.length} components.`);
+    if (componentsDefinitions.length === 0) {
+        return {
+            output: NO_COMPONENT_PLACEHOLDER_COMMENT,
+            stats: {}
+        };
+    }
+    const formattedSchemasDefinitions = componentsDefinitions.reduce((acc, def)=>{
+        acc.push(// Definition
+        def.definition, // Add a newline between each interface declaration
+        factory.createIdentifier('\n'));
+        return acc;
+    }, []);
+    const allDefinitions = [
+        // Imports
+        ...imports.generateImportDefinition(),
+        // Add a newline after the import statement
+        factory.createIdentifier('\n'),
+        // Schemas
+        ...formattedSchemasDefinitions,
+        // Global
+        utils.generateSharedExtensionDefinition('ComponentSchemas', componentsDefinitions, {
+            strict
+        })
+    ];
+    const output = utils.emitDefinitions(allDefinitions);
+    const formattedOutput = await utils.format(output);
+    return {
+        output: formattedOutput,
+        stats: {}
+    };
+};
+
+exports.generateComponentsDefinitions = generateComponentsDefinitions;
+//# sourceMappingURL=index.js.map

package/dist/generators/components/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/generators/components/index.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { sortBy } from 'lodash';\n\nimport { models } from '../common';\nimport { resolveInterfaceNames } from '../common/interface-names';\nimport { emitDefinitions, format, generateSharedExtensionDefinition } from '../utils';\nimport type { GeneratorOptions } from '../utils';\n\nconst { factory } = ts;\n\nconst NO_COMPONENT_PLACEHOLDER_COMMENT = `/*\n * The app doesn't have any components yet.\n */\n`;\n\n/**\n * Generate type definitions for Strapi Components\n */\nexport const generateComponentsDefinitions = async (\n  options: GeneratorOptions = {} as GeneratorOptions\n) => {\n  const { strapi, strict = false } = options;\n\n  const { components } = strapi;\n\n  const schemas = sortBy(Object.values<models.utils.Schema>(components ?? {}), 'uid');\n  const interfaceNames = resolveInterfaceNames(\n    schemas.map(({ uid }) => uid),\n    options.logger,\n    { strict }\n  );\n  const componentsDefinitions = schemas.map((component) => ({\n    uid: component.uid,\n    definition: models.schema.generateSchemaDefinition(\n      component,\n      interfaceNames.get(component.uid),\n      { strict }\n    ),\n  }));\n\n  options.logger.debug(`Found ${componentsDefinitions.length} components.`);\n\n  if (componentsDefinitions.length === 0) {\n    return { output: NO_COMPONENT_PLACEHOLDER_COMMENT, stats: {} };\n  }\n\n  const formattedSchemasDefinitions = componentsDefinitions.reduce<any[]>((acc, def) => {\n    acc.push(\n      // Definition\n      def.definition,\n\n      // Add a newline between each interface declaration\n      factory.createIdentifier('\\n')\n    );\n\n    return acc;\n  }, []);\n\n  const allDefinitions = [\n    // Imports\n    ...models.imports.generateImportDefinition(),\n\n    // Add a newline after the import statement\n    factory.createIdentifier('\\n'),\n\n    // Schemas\n    ...formattedSchemasDefinitions,\n\n    // Global\n    generateSharedExtensionDefinition('ComponentSchemas', componentsDefinitions, { strict }),\n  ];\n\n  const output = emitDefinitions(allDefinitions);\n  const formattedOutput = await format(output);\n\n  return { output: formattedOutput, stats: {} };\n};\n"],"names":["factory","ts","NO_COMPONENT_PLACEHOLDER_COMMENT","generateComponentsDefinitions","options","strapi","strict","components","schemas","sortBy","Object","values","interfaceNames","resolveInterfaceNames","map","uid","logger","componentsDefinitions","component","definition","models","get","debug","length","output","stats","formattedSchemasDefinitions","reduce","acc","def","push","createIdentifier","allDefinitions","generateSharedExtensionDefinition","emitDefinitions","formattedOutput","format"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,MAAM,EAAEA,OAAO,EAAE,GAAGC,aAAAA;AAEpB,MAAMC,mCAAmC,CAAC;;;AAG1C,CAAC;AAED;;AAEC,IACM,MAAMC,6BAAAA,GAAgC,OAC3CC,OAAAA,GAA4B,EAAsB,GAAA;AAElD,IAAA,MAAM,EAAEC,MAAM,EAAEC,MAAAA,GAAS,KAAK,EAAE,GAAGF,OAAAA;IAEnC,MAAM,EAAEG,UAAU,EAAE,GAAGF,MAAAA;AAEvB,IAAA,MAAMG,UAAUC,QAAAA,CAAOC,MAAAA,CAAOC,MAAM,CAAsBJ,UAAAA,IAAc,EAAC,CAAA,EAAI,KAAA,CAAA;AAC7E,IAAA,MAAMK,gBAAAA,GAAiBC,oCAAAA,CACrBL,OAAAA,CAAQM,GAAG,CAAC,CAAC,EAAEC,GAAG,EAAE,GAAKA,GAAAA,CAAAA,EACzBX,OAAAA,CAAQY,MAAM,EACd;AAAEV,QAAAA;AAAO,KAAA,CAAA;AAEX,IAAA,MAAMW,wBAAwBT,OAAAA,CAAQM,GAAG,CAAC,CAACI,aAAe;AACxDH,YAAAA,GAAAA,EAAKG,UAAUH,GAAG;YAClBI,UAAAA,EAAYC,+BAAsC,CAChDF,SAAAA,EACAN,gBAAAA,CAAeS,GAAG,CAACH,SAAAA,CAAUH,GAAG,CAAA,EAChC;AAAET,gBAAAA;AAAO,aAAA;SAEb,CAAA,CAAA;IAEAF,OAAAA,CAAQY,MAAM,CAACM,KAAK,CAAC,CAAC,MAAM,EAAEL,qBAAAA,CAAsBM,MAAM,CAAC,YAAY,CAAC,CAAA;IAExE,IAAIN,qBAAAA,CAAsBM,MAAM,KAAK,CAAA,EAAG;QACtC,OAAO;YAAEC,MAAAA,EAAQtB,gCAAAA;AAAkCuB,YAAAA,KAAAA,EAAO;AAAG,SAAA;AAC/D,IAAA;AAEA,IAAA,MAAMC,2BAAAA,GAA8BT,qBAAAA,CAAsBU,MAAM,CAAQ,CAACC,GAAAA,EAAKC,GAAAA,GAAAA;QAC5ED,GAAAA,CAAIE,IAAI;QAEND,GAAAA,CAAIV,UAAU;AAGdnB,QAAAA,OAAAA,CAAQ+B,gBAAgB,CAAC,IAAA,CAAA,CAAA;QAG3B,OAAOH,GAAAA;AACT,IAAA,CAAA,EAAG,EAAE,CAAA;AAEL,IAAA,MAAMI,cAAAA,GAAiB;;WAElBZ,gCAAuC,EAAA;;AAG1CpB,QAAAA,OAAAA,CAAQ+B,gBAAgB,CAAC,IAAA,CAAA;;AAGtBL,QAAAA,GAAAA,2BAAAA;;AAGHO,QAAAA,uCAAAA,CAAkC,oBAAoBhB,qBAAAA,EAAuB;AAAEX,YAAAA;AAAO,SAAA;AACvF,KAAA;AAED,IAAA,MAAMkB,SAASU,qBAAAA,CAAgBF,cAAAA,CAAAA;IAC/B,MAAMG,eAAAA,GAAkB,MAAMC,YAAAA,CAAOZ,MAAAA,CAAAA;IAErC,OAAO;QAAEA,MAAAA,EAAQW,eAAAA;AAAiBV,QAAAA,KAAAA,EAAO;AAAG,KAAA;AAC9C;;;;"}

package/dist/generators/components/index.mjs

@@ -0,0 +1,62 @@
+import * as ts from 'typescript';
+import { sortBy } from 'lodash';
+import { generateSchemaDefinition } from '../common/models/schema.mjs';
+import { generateImportDefinition } from '../common/imports.mjs';
+import { resolveInterfaceNames } from '../common/interface-names.mjs';
+import { generateSharedExtensionDefinition, emitDefinitions, format } from '../utils.mjs';
+
+const { factory } = ts;
+const NO_COMPONENT_PLACEHOLDER_COMMENT = `/*
+ * The app doesn't have any components yet.
+ */
+`;
+/**
+ * Generate type definitions for Strapi Components
+ */ const generateComponentsDefinitions = async (options = {})=>{
+    const { strapi, strict = false } = options;
+    const { components } = strapi;
+    const schemas = sortBy(Object.values(components ?? {}), 'uid');
+    const interfaceNames = resolveInterfaceNames(schemas.map(({ uid })=>uid), options.logger, {
+        strict
+    });
+    const componentsDefinitions = schemas.map((component)=>({
+            uid: component.uid,
+            definition: generateSchemaDefinition(component, interfaceNames.get(component.uid), {
+                strict
+            })
+        }));
+    options.logger.debug(`Found ${componentsDefinitions.length} components.`);
+    if (componentsDefinitions.length === 0) {
+        return {
+            output: NO_COMPONENT_PLACEHOLDER_COMMENT,
+            stats: {}
+        };
+    }
+    const formattedSchemasDefinitions = componentsDefinitions.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
+        generateSharedExtensionDefinition('ComponentSchemas', componentsDefinitions, {
+            strict
+        })
+    ];
+    const output = emitDefinitions(allDefinitions);
+    const formattedOutput = await format(output);
+    return {
+        output: formattedOutput,
+        stats: {}
+    };
+};
+
+export { generateComponentsDefinitions };
+//# sourceMappingURL=index.mjs.map

package/dist/generators/components/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../src/generators/components/index.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { sortBy } from 'lodash';\n\nimport { models } from '../common';\nimport { resolveInterfaceNames } from '../common/interface-names';\nimport { emitDefinitions, format, generateSharedExtensionDefinition } from '../utils';\nimport type { GeneratorOptions } from '../utils';\n\nconst { factory } = ts;\n\nconst NO_COMPONENT_PLACEHOLDER_COMMENT = `/*\n * The app doesn't have any components yet.\n */\n`;\n\n/**\n * Generate type definitions for Strapi Components\n */\nexport const generateComponentsDefinitions = async (\n  options: GeneratorOptions = {} as GeneratorOptions\n) => {\n  const { strapi, strict = false } = options;\n\n  const { components } = strapi;\n\n  const schemas = sortBy(Object.values<models.utils.Schema>(components ?? {}), 'uid');\n  const interfaceNames = resolveInterfaceNames(\n    schemas.map(({ uid }) => uid),\n    options.logger,\n    { strict }\n  );\n  const componentsDefinitions = schemas.map((component) => ({\n    uid: component.uid,\n    definition: models.schema.generateSchemaDefinition(\n      component,\n      interfaceNames.get(component.uid),\n      { strict }\n    ),\n  }));\n\n  options.logger.debug(`Found ${componentsDefinitions.length} components.`);\n\n  if (componentsDefinitions.length === 0) {\n    return { output: NO_COMPONENT_PLACEHOLDER_COMMENT, stats: {} };\n  }\n\n  const formattedSchemasDefinitions = componentsDefinitions.reduce<any[]>((acc, def) => {\n    acc.push(\n      // Definition\n      def.definition,\n\n      // Add a newline between each interface declaration\n      factory.createIdentifier('\\n')\n    );\n\n    return acc;\n  }, []);\n\n  const allDefinitions = [\n    // Imports\n    ...models.imports.generateImportDefinition(),\n\n    // Add a newline after the import statement\n    factory.createIdentifier('\\n'),\n\n    // Schemas\n    ...formattedSchemasDefinitions,\n\n    // Global\n    generateSharedExtensionDefinition('ComponentSchemas', componentsDefinitions, { strict }),\n  ];\n\n  const output = emitDefinitions(allDefinitions);\n  const formattedOutput = await format(output);\n\n  return { output: formattedOutput, stats: {} };\n};\n"],"names":["factory","ts","NO_COMPONENT_PLACEHOLDER_COMMENT","generateComponentsDefinitions","options","strapi","strict","components","schemas","sortBy","Object","values","interfaceNames","resolveInterfaceNames","map","uid","logger","componentsDefinitions","component","definition","models","get","debug","length","output","stats","formattedSchemasDefinitions","reduce","acc","def","push","createIdentifier","allDefinitions","generateSharedExtensionDefinition","emitDefinitions","formattedOutput","format"],"mappings":";;;;;;;AAQA,MAAM,EAAEA,OAAO,EAAE,GAAGC,EAAAA;AAEpB,MAAMC,mCAAmC,CAAC;;;AAG1C,CAAC;AAED;;AAEC,IACM,MAAMC,6BAAAA,GAAgC,OAC3CC,OAAAA,GAA4B,EAAsB,GAAA;AAElD,IAAA,MAAM,EAAEC,MAAM,EAAEC,MAAAA,GAAS,KAAK,EAAE,GAAGF,OAAAA;IAEnC,MAAM,EAAEG,UAAU,EAAE,GAAGF,MAAAA;AAEvB,IAAA,MAAMG,UAAUC,MAAAA,CAAOC,MAAAA,CAAOC,MAAM,CAAsBJ,UAAAA,IAAc,EAAC,CAAA,EAAI,KAAA,CAAA;AAC7E,IAAA,MAAMK,cAAAA,GAAiBC,qBAAAA,CACrBL,OAAAA,CAAQM,GAAG,CAAC,CAAC,EAAEC,GAAG,EAAE,GAAKA,GAAAA,CAAAA,EACzBX,OAAAA,CAAQY,MAAM,EACd;AAAEV,QAAAA;AAAO,KAAA,CAAA;AAEX,IAAA,MAAMW,wBAAwBT,OAAAA,CAAQM,GAAG,CAAC,CAACI,aAAe;AACxDH,YAAAA,GAAAA,EAAKG,UAAUH,GAAG;YAClBI,UAAAA,EAAYC,wBAAsC,CAChDF,SAAAA,EACAN,cAAAA,CAAeS,GAAG,CAACH,SAAAA,CAAUH,GAAG,CAAA,EAChC;AAAET,gBAAAA;AAAO,aAAA;SAEb,CAAA,CAAA;IAEAF,OAAAA,CAAQY,MAAM,CAACM,KAAK,CAAC,CAAC,MAAM,EAAEL,qBAAAA,CAAsBM,MAAM,CAAC,YAAY,CAAC,CAAA;IAExE,IAAIN,qBAAAA,CAAsBM,MAAM,KAAK,CAAA,EAAG;QACtC,OAAO;YAAEC,MAAAA,EAAQtB,gCAAAA;AAAkCuB,YAAAA,KAAAA,EAAO;AAAG,SAAA;AAC/D,IAAA;AAEA,IAAA,MAAMC,2BAAAA,GAA8BT,qBAAAA,CAAsBU,MAAM,CAAQ,CAACC,GAAAA,EAAKC,GAAAA,GAAAA;QAC5ED,GAAAA,CAAIE,IAAI;QAEND,GAAAA,CAAIV,UAAU;AAGdnB,QAAAA,OAAAA,CAAQ+B,gBAAgB,CAAC,IAAA,CAAA,CAAA;QAG3B,OAAOH,GAAAA;AACT,IAAA,CAAA,EAAG,EAAE,CAAA;AAEL,IAAA,MAAMI,cAAAA,GAAiB;;WAElBZ,wBAAuC,EAAA;;AAG1CpB,QAAAA,OAAAA,CAAQ+B,gBAAgB,CAAC,IAAA,CAAA;;AAGtBL,QAAAA,GAAAA,2BAAAA;;AAGHO,QAAAA,iCAAAA,CAAkC,oBAAoBhB,qBAAAA,EAAuB;AAAEX,YAAAA;AAAO,SAAA;AACvF,KAAA;AAED,IAAA,MAAMkB,SAASU,eAAAA,CAAgBF,cAAAA,CAAAA;IAC/B,MAAMG,eAAAA,GAAkB,MAAMC,MAAAA,CAAOZ,MAAAA,CAAAA;IAErC,OAAO;QAAEA,MAAAA,EAAQW,eAAAA;AAAiBV,QAAAA,KAAAA,EAAO;AAAG,KAAA;AAC9C;;;;"}

package/dist/generators/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const TYPES_ROOT_DIR = "types";
+export declare const GENERATED_OUT_DIR = "generated";
+//# sourceMappingURL=constants.d.ts.map

package/dist/generators/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/generators/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,UAAU,CAAC;AACtC,eAAO,MAAM,iBAAiB,cAAc,CAAC"}

package/dist/generators/constants.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const TYPES_ROOT_DIR = 'types';
+const GENERATED_OUT_DIR = 'generated';
+
+exports.GENERATED_OUT_DIR = GENERATED_OUT_DIR;
+exports.TYPES_ROOT_DIR = TYPES_ROOT_DIR;
+//# sourceMappingURL=constants.js.map

package/dist/generators/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../../src/generators/constants.ts"],"sourcesContent":["export const TYPES_ROOT_DIR = 'types';\nexport const GENERATED_OUT_DIR = 'generated';\n"],"names":["TYPES_ROOT_DIR","GENERATED_OUT_DIR"],"mappings":";;AAAO,MAAMA,iBAAiB;AACvB,MAAMC,oBAAoB;;;;;"}

package/dist/generators/constants.mjs

@@ -0,0 +1,5 @@
+const TYPES_ROOT_DIR = 'types';
+const GENERATED_OUT_DIR = 'generated';
+
+export { GENERATED_OUT_DIR, TYPES_ROOT_DIR };
+//# sourceMappingURL=constants.mjs.map

package/dist/generators/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","sources":["../../src/generators/constants.ts"],"sourcesContent":["export const TYPES_ROOT_DIR = 'types';\nexport const GENERATED_OUT_DIR = 'generated';\n"],"names":["TYPES_ROOT_DIR","GENERATED_OUT_DIR"],"mappings":"AAAO,MAAMA,iBAAiB;AACvB,MAAMC,oBAAoB;;;;"}

package/dist/generators/content-types/index.d.ts

@@ -0,0 +1,9 @@
+import type { GeneratorOptions } from '../utils';
+/**
+ * Generate type definitions for Strapi Content-Types
+ */
+export declare const generateContentTypesDefinitions: (options?: GeneratorOptions) => Promise<{
+    output: string;
+    stats: {};
+}>;
+//# sourceMappingURL=index.d.ts.map