@backstage/frontend-plugin-api 0.6.7 → 0.6.8-next.1

package/dist/extensions/createTranslationExtension.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"createTranslationExtension.esm.js","sources":["../../src/extensions/createTranslationExtension.ts"],"sourcesContent":["/*\n * Copyright 2023 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TranslationMessages, TranslationResource } from '../translation';\nimport { createExtension, createExtensionDataRef } from '../wiring';\n\n/** @public */\nexport function createTranslationExtension(options: {\n  name?: string;\n  resource: TranslationResource | TranslationMessages;\n}) {\n  return createExtension({\n    kind: 'translation',\n    namespace: options.resource.id,\n    name: options.name,\n    attachTo: { id: 'app', input: 'translations' },\n    output: {\n      resource: createTranslationExtension.translationDataRef,\n    },\n    factory: () => ({ resource: options.resource }),\n  });\n}\n\n/** @public */\nexport namespace createTranslationExtension {\n  export const translationDataRef = createExtensionDataRef<\n    TranslationResource | TranslationMessages\n  >('core.translation.translation');\n}\n"],"names":["createTranslationExtension"],"mappings":";;;AAoBO,SAAS,2BAA2B,OAGxC,EAAA;AACD,EAAA,OAAO,eAAgB,CAAA;AAAA,IACrB,IAAM,EAAA,aAAA;AAAA,IACN,SAAA,EAAW,QAAQ,QAAS,CAAA,EAAA;AAAA,IAC5B,MAAM,OAAQ,CAAA,IAAA;AAAA,IACd,QAAU,EAAA,EAAE,EAAI,EAAA,KAAA,EAAO,OAAO,cAAe,EAAA;AAAA,IAC7C,MAAQ,EAAA;AAAA,MACN,UAAU,0BAA2B,CAAA,kBAAA;AAAA,KACvC;AAAA,IACA,OAAS,EAAA,OAAO,EAAE,QAAA,EAAU,QAAQ,QAAS,EAAA,CAAA;AAAA,GAC9C,CAAA,CAAA;AACH,CAAA;AAAA,CAGO,CAAUA,2BAAV,KAAA;AACE,EAAMA,2BAAAA,CAAA,kBAAqB,GAAA,sBAAA,CAEhC,8BAA8B,CAAA,CAAA;AAAA,CAHjB,EAAA,0BAAA,KAAA,0BAAA,GAAA,EAAA,CAAA,CAAA;;;;"}
+{"version":3,"file":"createTranslationExtension.esm.js","sources":["../../src/extensions/createTranslationExtension.ts"],"sourcesContent":["/*\n * Copyright 2023 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TranslationMessages, TranslationResource } from '../translation';\nimport { createExtension, createExtensionDataRef } from '../wiring';\n\n/** @public */\nexport function createTranslationExtension(options: {\n  name?: string;\n  resource: TranslationResource | TranslationMessages;\n}) {\n  return createExtension({\n    kind: 'translation',\n    namespace: options.resource.id,\n    name: options.name,\n    attachTo: { id: 'app', input: 'translations' },\n    output: {\n      resource: createTranslationExtension.translationDataRef,\n    },\n    factory: () => ({ resource: options.resource }),\n  });\n}\n\n/** @public */\nexport namespace createTranslationExtension {\n  export const translationDataRef = createExtensionDataRef<\n    TranslationResource | TranslationMessages\n  >().with({ id: 'core.translation.translation' });\n}\n"],"names":["createTranslationExtension"],"mappings":";;;;AAoBO,SAAS,2BAA2B,OAGxC,EAAA;AACD,EAAA,OAAO,eAAgB,CAAA;AAAA,IACrB,IAAM,EAAA,aAAA;AAAA,IACN,SAAA,EAAW,QAAQ,QAAS,CAAA,EAAA;AAAA,IAC5B,MAAM,OAAQ,CAAA,IAAA;AAAA,IACd,QAAU,EAAA,EAAE,EAAI,EAAA,KAAA,EAAO,OAAO,cAAe,EAAA;AAAA,IAC7C,MAAQ,EAAA;AAAA,MACN,UAAU,0BAA2B,CAAA,kBAAA;AAAA,KACvC;AAAA,IACA,OAAS,EAAA,OAAO,EAAE,QAAA,EAAU,QAAQ,QAAS,EAAA,CAAA;AAAA,GAC9C,CAAA,CAAA;AACH,CAAA;AAAA,CAGO,CAAUA,2BAAV,KAAA;AACE,EAAMA,2BAAAA,CAAA,qBAAqB,sBAEhC,EAAA,CAAE,KAAK,EAAE,EAAA,EAAI,gCAAgC,CAAA,CAAA;AAAA,CAHhC,EAAA,0BAAA,KAAA,0BAAA,GAAA,EAAA,CAAA,CAAA;;;;"}

package/dist/index.d.ts

@@ -4,9 +4,9 @@ import * as _backstage_core_plugin_api from '@backstage/core-plugin-api';
 import { ApiRef, AnyApiRef, AnyApiFactory, IconComponent as IconComponent$1, SignInPageProps, AppTheme } from '@backstage/core-plugin-api';
 export { AlertApi, AlertMessage, AnyApiFactory, AnyApiRef, ApiFactory, ApiHolder, ApiRef, ApiRefConfig, AppTheme, AppThemeApi, AuthProviderInfo, AuthRequestOptions, BackstageIdentityApi, BackstageIdentityResponse, BackstageUserIdentity, ConfigApi, DiscoveryApi, ErrorApi, ErrorApiError, ErrorApiErrorContext, FeatureFlag, FeatureFlagState, FeatureFlagsApi, FeatureFlagsSaveOptions, FetchApi, IdentityApi, OAuthApi, OAuthRequestApi, OAuthRequester, OAuthRequesterOptions, OAuthScope, OpenIdConnectApi, PendingOAuthRequest, ProfileInfo, ProfileInfoApi, SessionApi, SessionState, StorageApi, StorageValueSnapshot, TypesToApiRefs, alertApiRef, appThemeApiRef, atlassianAuthApiRef, bitbucketAuthApiRef, bitbucketServerAuthApiRef, configApiRef, createApiFactory, createApiRef, discoveryApiRef, errorApiRef, featureFlagsApiRef, fetchApiRef, githubAuthApiRef, gitlabAuthApiRef, googleAuthApiRef, identityApiRef, microsoftAuthApiRef, oauthRequestApiRef, oktaAuthApiRef, oneloginAuthApiRef, storageApiRef, useApi, useApiHolder, vmwareCloudAuthApiRef, withApis } from '@backstage/core-plugin-api';
 import { JsonObject } from '@backstage/types';
+import { z, ZodSchema, ZodTypeDef } from 'zod';
 import { TranslationResource, TranslationMessages } from '@backstage/core-plugin-api/alpha';
 export { TranslationMessages, TranslationMessagesOptions, TranslationRef, TranslationRefOptions, TranslationResource, TranslationResourceOptions, createTranslationMessages, createTranslationRef, createTranslationResource, useTranslationRef } from '@backstage/core-plugin-api/alpha';
-import { z, ZodSchema, ZodTypeDef } from 'zod';
 
 /**
  * Common analytics context attributes.
@@ -233,40 +233,65 @@ declare function useRouteRef<TParams extends AnyRouteRefParams>(routeRef: RouteR
 declare function useRouteRefParams<Params extends AnyRouteRefParams>(_routeRef: RouteRef<Params> | SubRouteRef<Params>): Params;
 
 /** @public */
-type ExtensionDataRef<TData, TConfig extends {
+type ExtensionDataValue<TData, TId extends string> = {
+    readonly $$type: '@backstage/ExtensionDataValue';
+    readonly id: TId;
+    readonly value: TData;
+};
+/** @public */
+type ExtensionDataRef<TData, TId extends string = string, TConfig extends {
     optional?: true;
 } = {}> = {
-    id: string;
-    T: TData;
-    config: TConfig;
-    $$type: '@backstage/ExtensionDataRef';
+    readonly $$type: '@backstage/ExtensionDataRef';
+    readonly id: TId;
+    readonly T: TData;
+    readonly config: TConfig;
 };
 /** @public */
-interface ConfigurableExtensionDataRef<TData, TConfig extends {
+type ExtensionDataRefToValue<TDataRef extends AnyExtensionDataRef> = TDataRef extends ExtensionDataRef<infer IData, infer IId, any> ? ExtensionDataValue<IData, IId> : never;
+/** @public */
+type AnyExtensionDataRef = ExtensionDataRef<unknown, string, {
     optional?: true;
-} = {}> extends ExtensionDataRef<TData, TConfig> {
-    optional(): ConfigurableExtensionDataRef<TData, TData & {
+}>;
+/** @public */
+interface ConfigurableExtensionDataRef<TData, TId extends string, TConfig extends {
+    optional?: true;
+} = {}> extends ExtensionDataRef<TData, TId, TConfig> {
+    optional(): ConfigurableExtensionDataRef<TData, TId, TData & {
         optional: true;
     }>;
+    (t: TData): ExtensionDataValue<TData, TId>;
 }
+/**
+ * @public
+ * @deprecated Use the following form instead: `createExtensionDataRef<Type>().with({ id: 'core.foo' })`
+ */
+declare function createExtensionDataRef<TData>(id: string): ConfigurableExtensionDataRef<TData, string>;
 /** @public */
-declare function createExtensionDataRef<TData>(id: string): ConfigurableExtensionDataRef<TData>;
+declare function createExtensionDataRef<TData>(): {
+    with<TId extends string>(options: {
+        id: TId;
+    }): ConfigurableExtensionDataRef<TData, TId>;
+};
 
 /** @public */
 declare const coreExtensionData: {
-    reactElement: ConfigurableExtensionDataRef<JSX$1.Element, {}>;
-    routePath: ConfigurableExtensionDataRef<string, {}>;
-    routeRef: ConfigurableExtensionDataRef<RouteRef<AnyRouteRefParams>, {}>;
+    reactElement: ConfigurableExtensionDataRef<JSX$1.Element, "core.reactElement", {}>;
+    routePath: ConfigurableExtensionDataRef<string, "core.routing.path", {}>;
+    routeRef: ConfigurableExtensionDataRef<RouteRef<AnyRouteRefParams>, "core.routing.ref", {}>;
 };
 
 /** @public */
-type PortableSchema<TOutput> = {
-    parse: (input: unknown) => TOutput;
+type PortableSchema<TOutput, TInput = TOutput> = {
+    parse: (input: TInput) => TOutput;
     schema: JsonObject;
 };
 
-/** @public */
-declare function createSchemaFromZod<TOutput, TInput>(schemaCreator: (zImpl: typeof z) => ZodSchema<TOutput, ZodTypeDef, TInput>): PortableSchema<TOutput>;
+/**
+ * @public
+ * @deprecated Use the `config.schema` option of `createExtension` instead, or use `createExtensionBlueprint`.
+ */
+declare function createSchemaFromZod<TOutput, TInput>(schemaCreator: (zImpl: typeof z) => ZodSchema<TOutput, ZodTypeDef, TInput>): PortableSchema<TOutput, TInput>;
 
 /**
  * Utility type to expand type aliases into their equivalent type.
@@ -289,32 +314,63 @@ type CoreErrorBoundaryFallbackProps = {
 };
 
 /** @public */
-interface ExtensionInput<TExtensionData extends AnyExtensionDataMap, TConfig extends {
+interface ExtensionInput<TExtensionData extends ExtensionDataRef<unknown, string, {
+    optional?: true;
+}>, TConfig extends {
+    singleton: boolean;
+    optional: boolean;
+}> {
+    $$type: '@backstage/ExtensionInput';
+    extensionData: Array<TExtensionData>;
+    config: TConfig;
+}
+/**
+ * @public
+ * @deprecated This type will be removed. Use `ExtensionInput` instead.
+ */
+interface LegacyExtensionInput<TExtensionDataMap extends AnyExtensionDataMap, TConfig extends {
     singleton: boolean;
     optional: boolean;
 }> {
     $$type: '@backstage/ExtensionInput';
-    extensionData: TExtensionData;
+    extensionData: TExtensionDataMap;
     config: TConfig;
 }
+/**
+ * @public
+ * @deprecated Use the following form instead: `createExtensionInput([dataRef1, dataRef2])`
+ */
+declare function createExtensionInput<TExtensionDataMap extends AnyExtensionDataMap, TConfig extends {
+    singleton?: boolean;
+    optional?: boolean;
+}>(extensionData: TExtensionDataMap, config?: TConfig): LegacyExtensionInput<TExtensionDataMap, {
+    singleton: TConfig['singleton'] extends true ? true : false;
+    optional: TConfig['optional'] extends true ? true : false;
+}>;
 /** @public */
-declare function createExtensionInput<TExtensionData extends AnyExtensionDataMap, TConfig extends {
+declare function createExtensionInput<UExtensionData extends ExtensionDataRef<unknown, string, {
+    optional?: true;
+}>, TConfig extends {
     singleton?: boolean;
     optional?: boolean;
-}>(extensionData: TExtensionData, config?: TConfig): ExtensionInput<TExtensionData, {
+}>(extensionData: Array<UExtensionData>, config?: TConfig): ExtensionInput<UExtensionData, {
     singleton: TConfig['singleton'] extends true ? true : false;
     optional: TConfig['optional'] extends true ? true : false;
 }>;
 
-/** @public */
+/**
+ * @public
+ * @deprecated Extension data maps will be removed.
+ */
 type AnyExtensionDataMap = {
-    [name in string]: ExtensionDataRef<unknown, {
-        optional?: true;
-    }>;
+    [name in string]: AnyExtensionDataRef;
 };
-/** @public */
+/**
+ * @public
+ * @deprecated This type will be removed.
+ */
 type AnyExtensionInputMap = {
-    [inputName in string]: ExtensionInput<AnyExtensionDataMap, {
+    [inputName in string]: LegacyExtensionInput<AnyExtensionDataMap, {
         optional: boolean;
         singleton: boolean;
     }>;
@@ -322,6 +378,7 @@ type AnyExtensionInputMap = {
 /**
  * Converts an extension data map into the matching concrete data values type.
  * @public
+ * @deprecated Extension data maps will be removed.
  */
 type ExtensionDataValues<TExtensionData extends AnyExtensionDataMap> = {
     [DataName in keyof TExtensionData as TExtensionData[DataName]['config'] extends {
@@ -332,25 +389,36 @@ type ExtensionDataValues<TExtensionData extends AnyExtensionDataMap> = {
         optional: true;
     } ? DataName : never]?: TExtensionData[DataName]['T'];
 };
+/** @public */
+type ExtensionDataContainer<UExtensionData extends AnyExtensionDataRef> = {
+    get<TId extends UExtensionData['id']>(ref: ExtensionDataRef<any, TId, any>): UExtensionData extends ExtensionDataRef<infer IData, TId, infer IConfig> ? IConfig['optional'] extends true ? IData | undefined : IData : never;
+};
 /**
  * Convert a single extension input into a matching resolved input.
  * @public
  */
-type ResolvedExtensionInput<TExtensionData extends AnyExtensionDataMap> = {
+type ResolvedExtensionInput<TExtensionInput extends ExtensionInput<any, any>> = TExtensionInput['extensionData'] extends Array<AnyExtensionDataRef> ? {
     node: AppNode;
-    output: ExtensionDataValues<TExtensionData>;
-};
+} & ExtensionDataContainer<TExtensionInput['extensionData'][number]> : TExtensionInput['extensionData'] extends AnyExtensionDataMap ? {
+    node: AppNode;
+    output: ExtensionDataValues<TExtensionInput['extensionData']>;
+} : never;
 /**
  * Converts an extension input map into a matching collection of resolved inputs.
  * @public
  */
 type ResolvedExtensionInputs<TInputs extends {
-    [name in string]: ExtensionInput<any, any>;
+    [name in string]: ExtensionInput<any, any> | LegacyExtensionInput<any, any>;
 }> = {
-    [InputName in keyof TInputs]: false extends TInputs[InputName]['config']['singleton'] ? Array<Expand<ResolvedExtensionInput<TInputs[InputName]['extensionData']>>> : false extends TInputs[InputName]['config']['optional'] ? Expand<ResolvedExtensionInput<TInputs[InputName]['extensionData']>> : Expand<ResolvedExtensionInput<TInputs[InputName]['extensionData']> | undefined>;
+    [InputName in keyof TInputs]: false extends TInputs[InputName]['config']['singleton'] ? Array<Expand<ResolvedExtensionInput<TInputs[InputName]>>> : false extends TInputs[InputName]['config']['optional'] ? Expand<ResolvedExtensionInput<TInputs[InputName]>> : Expand<ResolvedExtensionInput<TInputs[InputName]> | undefined>;
 };
-/** @public */
-interface CreateExtensionOptions<TOutput extends AnyExtensionDataMap, TInputs extends AnyExtensionInputMap, TConfig> {
+/**
+ * @public
+ * @deprecated This way of structuring the options is deprecated, this type will be removed in the future
+ */
+interface LegacyCreateExtensionOptions<TOutput extends AnyExtensionDataMap, TInputs extends AnyExtensionInputMap, TConfig, TConfigInput, TConfigSchema extends {
+    [key: string]: (zImpl: typeof z) => z.ZodType;
+}> {
     kind?: string;
     namespace?: string;
     name?: string;
@@ -361,15 +429,57 @@ interface CreateExtensionOptions<TOutput extends AnyExtensionDataMap, TInputs ex
     disabled?: boolean;
     inputs?: TInputs;
     output: TOutput;
-    configSchema?: PortableSchema<TConfig>;
-    factory(options: {
+    /** @deprecated - use `config.schema` instead */
+    configSchema?: PortableSchema<TConfig, TConfigInput>;
+    config?: {
+        schema: TConfigSchema;
+    };
+    factory(context: {
         node: AppNode;
-        config: TConfig;
+        config: TConfig & (string extends keyof TConfigSchema ? {} : {
+            [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+        });
         inputs: Expand<ResolvedExtensionInputs<TInputs>>;
     }): Expand<ExtensionDataValues<TOutput>>;
 }
+/** @ignore */
+type VerifyExtensionFactoryOutput<UDeclaredOutput extends AnyExtensionDataRef, UFactoryOutput extends ExtensionDataValue<any, any>> = (UDeclaredOutput extends any ? UDeclaredOutput['config']['optional'] extends true ? never : UDeclaredOutput['id'] : never) extends infer IRequiredOutputIds ? [IRequiredOutputIds] extends [UFactoryOutput['id']] ? {} : {
+    'Error: The extension factory is missing the following outputs': Exclude<IRequiredOutputIds, UFactoryOutput['id']>;
+} : never;
+/** @public */
+type CreateExtensionOptions<UOutput extends AnyExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+        optional: boolean;
+        singleton: boolean;
+    }>;
+}, TConfig, TConfigInput, TConfigSchema extends {
+    [key: string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>> = {
+    kind?: string;
+    namespace?: string;
+    name?: string;
+    attachTo: {
+        id: string;
+        input: string;
+    };
+    disabled?: boolean;
+    inputs?: TInputs;
+    output: Array<UOutput>;
+    /** @deprecated - use `config.schema` instead */
+    configSchema?: PortableSchema<TConfig, TConfigInput>;
+    config?: {
+        schema: TConfigSchema;
+    };
+    factory(context: {
+        node: AppNode;
+        config: TConfig & (string extends keyof TConfigSchema ? {} : {
+            [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+        });
+        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+    }): Iterable<UFactoryOutput>;
+} & VerifyExtensionFactoryOutput<UOutput, UFactoryOutput>;
 /** @public */
-interface ExtensionDefinition<TConfig> {
+interface ExtensionDefinition<TConfig, TConfigInput = TConfig> {
     $$type: '@backstage/ExtensionDefinition';
     readonly kind?: string;
     readonly namespace?: string;
@@ -379,13 +489,35 @@ interface ExtensionDefinition<TConfig> {
         input: string;
     };
     readonly disabled: boolean;
-    readonly configSchema?: PortableSchema<TConfig>;
+    readonly configSchema?: PortableSchema<TConfig, TConfigInput>;
 }
 /** @public */
-declare function createExtension<TOutput extends AnyExtensionDataMap, TInputs extends AnyExtensionInputMap, TConfig = never>(options: CreateExtensionOptions<TOutput, TInputs, TConfig>): ExtensionDefinition<TConfig>;
+declare function createExtension<UOutput extends AnyExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+        optional: boolean;
+        singleton: boolean;
+    }>;
+}, TConfig, TConfigInput, TConfigSchema extends {
+    [key: string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>>(options: CreateExtensionOptions<UOutput, TInputs, TConfig, TConfigInput, TConfigSchema, UFactoryOutput>): ExtensionDefinition<TConfig & (string extends keyof TConfigSchema ? {} : {
+    [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+}), TConfigInput & (string extends keyof TConfigSchema ? {} : z.input<z.ZodObject<{
+    [key in keyof TConfigSchema]: ReturnType<TConfigSchema[key]>;
+}>>)>;
+/**
+ * @public
+ * @deprecated - use the array format of `output` instead, see TODO-doc-link
+ */
+declare function createExtension<TOutput extends AnyExtensionDataMap, TInputs extends AnyExtensionInputMap, TConfig, TConfigInput, TConfigSchema extends {
+    [key: string]: (zImpl: typeof z) => z.ZodType;
+}>(options: LegacyCreateExtensionOptions<TOutput, TInputs, TConfig, TConfigInput, TConfigSchema>): ExtensionDefinition<TConfig & (string extends keyof TConfigSchema ? {} : {
+    [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+}), TConfigInput & (string extends keyof TConfigSchema ? {} : z.input<z.ZodObject<{
+    [key in keyof TConfigSchema]: ReturnType<TConfigSchema[key]>;
+}>>)>;
 
 /** @public */
-interface Extension<TConfig> {
+interface Extension<TConfig, TConfigInput = TConfig> {
     $$type: '@backstage/Extension';
     readonly id: string;
     readonly attachTo: {
@@ -393,7 +525,7 @@ interface Extension<TConfig> {
         input: string;
     };
     readonly disabled: boolean;
-    readonly configSchema?: PortableSchema<TConfig>;
+    readonly configSchema?: PortableSchema<TConfig, TConfigInput>;
 }
 
 /**
@@ -432,7 +564,7 @@ interface PluginOptions<Routes extends AnyRoutes, ExternalRoutes extends AnyExte
     id: string;
     routes?: Routes;
     externalRoutes?: ExternalRoutes;
-    extensions?: ExtensionDefinition<unknown>[];
+    extensions?: ExtensionDefinition<any, any>[];
     featureFlags?: FeatureFlagConfig[];
 }
 /** @public */
@@ -440,12 +572,125 @@ declare function createPlugin<Routes extends AnyRoutes = {}, ExternalRoutes exte
 
 /** @public */
 interface ExtensionOverridesOptions {
-    extensions: ExtensionDefinition<unknown>[];
+    extensions: ExtensionDefinition<any, any>[];
     featureFlags?: FeatureFlagConfig[];
 }
 /** @public */
 declare function createExtensionOverrides(options: ExtensionOverridesOptions): ExtensionOverrides;
 
+/**
+ * @public
+ */
+type CreateExtensionBlueprintOptions<TParams, UOutput extends AnyExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+        optional: boolean;
+        singleton: boolean;
+    }>;
+}, TConfigSchema extends {
+    [key in string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>, TDataRefs extends {
+    [name in string]: AnyExtensionDataRef;
+}> = {
+    kind: string;
+    namespace?: string;
+    attachTo: {
+        id: string;
+        input: string;
+    };
+    disabled?: boolean;
+    inputs?: TInputs;
+    output: Array<UOutput>;
+    config?: {
+        schema: TConfigSchema;
+    };
+    factory(params: TParams, context: {
+        node: AppNode;
+        config: {
+            [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+        };
+        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+    }): Iterable<UFactoryOutput>;
+    dataRefs?: TDataRefs;
+} & VerifyExtensionFactoryOutput<UOutput, UFactoryOutput>;
+/**
+ * @public
+ */
+interface ExtensionBlueprint<TParams, UOutput extends AnyExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+        optional: boolean;
+        singleton: boolean;
+    }>;
+}, UExtraOutput extends AnyExtensionDataRef, TConfig extends {
+    [key in string]: unknown;
+}, TConfigInput extends {
+    [key in string]: unknown;
+}, TDataRefs extends {
+    [name in string]: AnyExtensionDataRef;
+}> {
+    dataRefs: TDataRefs;
+    /**
+     * Creates a new extension from the blueprint.
+     *
+     * You must either pass `params` directly, or define a `factory` that can
+     * optionally call the original factory with the same params.
+     */
+    make<TExtensionConfigSchema extends {
+        [key in string]: (zImpl: typeof z) => z.ZodType;
+    }, UFactoryOutput extends ExtensionDataValue<any, any>>(args: {
+        namespace?: string;
+        name?: string;
+        attachTo?: {
+            id: string;
+            input: string;
+        };
+        disabled?: boolean;
+        inputs?: TInputs;
+        output?: Array<UExtraOutput>;
+        config?: {
+            schema: TExtensionConfigSchema & {
+                [KName in keyof TConfig]?: `Error: Config key '${KName & string}' is already defined in parent schema`;
+            };
+        };
+    } & (({
+        factory(originalFactory: (params: TParams, context?: {
+            config?: TConfig;
+            inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
+        }) => Iterable<ExtensionDataRefToValue<UOutput>>, context: {
+            node: AppNode;
+            config: TConfig & {
+                [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
+            };
+            inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+        }): Iterable<UFactoryOutput>;
+    } & VerifyExtensionFactoryOutput<UOutput & UExtraOutput, UFactoryOutput>) | {
+        params: TParams;
+    })): ExtensionDefinition<{
+        [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
+    } & TConfig, z.input<z.ZodObject<{
+        [key in keyof TExtensionConfigSchema]: ReturnType<TExtensionConfigSchema[key]>;
+    }>> & TConfigInput>;
+}
+/**
+ * A simpler replacement for wrapping up `createExtension` inside a kind or type. This allows for a cleaner API for creating
+ * types and instances of those types.
+ *
+ * @public
+ */
+declare function createExtensionBlueprint<TParams, UOutput extends AnyExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+        optional: boolean;
+        singleton: boolean;
+    }>;
+}, UExtraOutput extends AnyExtensionDataRef, TConfigSchema extends {
+    [key in string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>, TDataRefs extends {
+    [name in string]: AnyExtensionDataRef;
+} = never>(options: CreateExtensionBlueprintOptions<TParams, UOutput, TInputs, TConfigSchema, UFactoryOutput, TDataRefs>): ExtensionBlueprint<TParams, UOutput, TInputs, UExtraOutput, string extends keyof TConfigSchema ? {} : {
+    [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+}, string extends keyof TConfigSchema ? {} : z.input<z.ZodObject<{
+    [key in keyof TConfigSchema]: ReturnType<TConfigSchema[key]>;
+}>>, TDataRefs>;
+
 /**
  * The specification for this {@link AppNode} in the {@link AppTree}.
  *
@@ -461,7 +706,7 @@ interface AppNodeSpec {
         id: string;
         input: string;
     };
-    readonly extension: Extension<unknown>;
+    readonly extension: Extension<unknown, unknown>;
     readonly disabled: boolean;
     readonly config?: unknown;
     readonly source?: BackstagePlugin;
@@ -547,6 +792,11 @@ declare const appTreeApiRef: _backstage_core_plugin_api.ApiRef<AppTreeApi>;
 /** @public */
 interface ExtensionBoundaryProps {
     node: AppNode;
+    /**
+     * This explicitly marks the extension as routable for the purpose of
+     * capturing analytics events. If not provided, the extension boundary will be
+     * marked as routable if it outputs a routePath.
+     */
     routable?: boolean;
     children: ReactNode;
 }
@@ -783,10 +1033,10 @@ declare function createApiExtension<TConfig extends {}, TInputs extends AnyExten
 }) & {
     configSchema?: PortableSchema<TConfig>;
     inputs?: TInputs;
-}): ExtensionDefinition<TConfig>;
+}): ExtensionDefinition<TConfig & {}, TConfig & {}>;
 /** @public */
 declare namespace createApiExtension {
-    const factoryDataRef: ConfigurableExtensionDataRef<AnyApiFactory, {}>;
+    const factoryDataRef: ConfigurableExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
 }
 
 /**
@@ -837,7 +1087,7 @@ declare function createAppRootWrapperExtension<TConfig extends {}, TInputs exten
 declare namespace createAppRootWrapperExtension {
     const componentDataRef: ConfigurableExtensionDataRef<React.ComponentType<{
         children?: React.ReactNode;
-    }>, {}>;
+    }>, "app.root.wrapper", {}>;
 }
 
 /**
@@ -866,7 +1116,7 @@ declare function createRouterExtension<TConfig extends {}, TInputs extends AnyEx
 declare namespace createRouterExtension {
     const componentDataRef: ConfigurableExtensionDataRef<React.ComponentType<{
         children?: React.ReactNode;
-    }>, {}>;
+    }>, "app.router.wrapper", {}>;
 }
 
 /**
@@ -908,6 +1158,8 @@ declare function createNavItemExtension(options: {
     icon: IconComponent$1;
 }): ExtensionDefinition<{
     title: string;
+}, {
+    title?: string | undefined;
 }>;
 /** @public */
 declare namespace createNavItemExtension {
@@ -915,7 +1167,7 @@ declare namespace createNavItemExtension {
         title: string;
         icon: IconComponent$1;
         routeRef: RouteRef<undefined>;
-    }, {}>;
+    }, "core.nav-item.target", {}>;
 }
 
 /**
@@ -927,13 +1179,13 @@ declare function createNavLogoExtension(options: {
     namespace?: string;
     logoIcon: JSX.Element;
     logoFull: JSX.Element;
-}): ExtensionDefinition<never>;
+}): ExtensionDefinition<{}, {}>;
 /** @public */
 declare namespace createNavLogoExtension {
     const logoElementsDataRef: ConfigurableExtensionDataRef<{
         logoIcon?: JSX.Element | undefined;
         logoFull?: JSX.Element | undefined;
-    }, {}>;
+    }, "core.nav-logo.logo-elements", {}>;
 }
 
 /**
@@ -957,14 +1209,14 @@ declare function createSignInPageExtension<TConfig extends {}, TInputs extends A
 }): ExtensionDefinition<TConfig>;
 /** @public */
 declare namespace createSignInPageExtension {
-    const componentDataRef: ConfigurableExtensionDataRef<React.ComponentType<SignInPageProps>, {}>;
+    const componentDataRef: ConfigurableExtensionDataRef<React.ComponentType<SignInPageProps>, "core.sign-in-page.component", {}>;
 }
 
 /** @public */
-declare function createThemeExtension(theme: AppTheme): ExtensionDefinition<never>;
+declare function createThemeExtension(theme: AppTheme): ExtensionDefinition<{}, {}>;
 /** @public */
 declare namespace createThemeExtension {
-    const themeDataRef: ConfigurableExtensionDataRef<AppTheme, {}>;
+    const themeDataRef: ConfigurableExtensionDataRef<AppTheme, "core.theme.theme", {}>;
 }
 
 /** @public */
@@ -985,25 +1237,49 @@ declare function createComponentExtension<TProps extends {}, TConfig extends {},
             inputs: Expand<ResolvedExtensionInputs<TInputs>>;
         }) => ComponentType<TProps>;
     };
-}): ExtensionDefinition<TConfig>;
+}): ExtensionDefinition<TConfig & {}, TConfig & {}>;
 /** @public */
 declare namespace createComponentExtension {
     const componentDataRef: ConfigurableExtensionDataRef<{
         ref: ComponentRef;
         impl: ComponentType;
-    }, {}>;
+    }, "core.component.component", {}>;
 }
 
 /** @public */
 declare function createTranslationExtension(options: {
     name?: string;
     resource: TranslationResource | TranslationMessages;
-}): ExtensionDefinition<never>;
+}): ExtensionDefinition<{}, {}>;
 /** @public */
 declare namespace createTranslationExtension {
     const translationDataRef: ConfigurableExtensionDataRef<TranslationResource<string> | TranslationMessages<string, {
         [x: string]: string;
-    }, boolean>, {}>;
+    }, boolean>, "core.translation.translation", {}>;
 }
 
-export { type AnalyticsApi, AnalyticsContext, type AnalyticsContextValue, type AnalyticsEvent, type AnalyticsEventAttributes, type AnalyticsTracker, type AnyExtensionDataMap, type AnyExtensionInputMap, type AnyExternalRoutes, type AnyRouteRefParams, type AnyRoutes, type AppNode, type AppNodeEdges, type AppNodeInstance, type AppNodeSpec, type AppTree, type AppTreeApi, type BackstagePlugin, type CommonAnalyticsContext, type ComponentRef, type ComponentsApi, type ConfigurableExtensionDataRef, type CoreErrorBoundaryFallbackProps, type CoreNotFoundErrorPageProps, type CoreProgressProps, type CreateExtensionOptions, type Extension, ExtensionBoundary, type ExtensionBoundaryProps, type ExtensionDataRef, type ExtensionDataValues, type ExtensionDefinition, type ExtensionInput, type ExtensionOverrides, type ExtensionOverridesOptions, type ExternalRouteRef, type FeatureFlagConfig, type FrontendFeature, type IconComponent, type IconsApi, type PluginOptions, type PortableSchema, type ResolvedExtensionInput, type ResolvedExtensionInputs, type RouteFunc, type RouteRef, type RouteResolutionApi, type RouteResolutionApiResolveOptions, type SubRouteRef, analyticsApiRef, appTreeApiRef, componentsApiRef, coreComponentRefs, coreExtensionData, createApiExtension, createAppRootElementExtension, createAppRootWrapperExtension, createComponentExtension, createComponentRef, createExtension, createExtensionDataRef, createExtensionInput, createExtensionOverrides, createExternalRouteRef, createNavItemExtension, createNavLogoExtension, createPageExtension, createPlugin, createRouteRef, createRouterExtension, createSchemaFromZod, createSignInPageExtension, createSubRouteRef, createThemeExtension, createTranslationExtension, iconsApiRef, routeResolutionApiRef, useAnalytics, useComponentRef, useRouteRef, useRouteRefParams };
+/** @public */
+declare const IconBundleBlueprint: ExtensionBlueprint<{
+    icons: {
+        [x: string]: IconComponent;
+    };
+}, ConfigurableExtensionDataRef<{
+    [x: string]: IconComponent;
+}, "core.icons", {}>, {
+    [x: string]: ExtensionInput<AnyExtensionDataRef, {
+        optional: boolean;
+        singleton: boolean;
+    }>;
+}, AnyExtensionDataRef, {
+    icons: string;
+    test: string;
+}, {
+    test: string;
+    icons?: string | undefined;
+}, {
+    icons: ConfigurableExtensionDataRef<{
+        [x: string]: IconComponent;
+    }, "core.icons", {}>;
+}>;
+
+export { type AnalyticsApi, AnalyticsContext, type AnalyticsContextValue, type AnalyticsEvent, type AnalyticsEventAttributes, type AnalyticsTracker, type AnyExtensionDataMap, type AnyExtensionDataRef, type AnyExtensionInputMap, type AnyExternalRoutes, type AnyRouteRefParams, type AnyRoutes, type AppNode, type AppNodeEdges, type AppNodeInstance, type AppNodeSpec, type AppTree, type AppTreeApi, type BackstagePlugin, type CommonAnalyticsContext, type ComponentRef, type ComponentsApi, type ConfigurableExtensionDataRef, type CoreErrorBoundaryFallbackProps, type CoreNotFoundErrorPageProps, type CoreProgressProps, type CreateExtensionBlueprintOptions, type CreateExtensionOptions, type Extension, type ExtensionBlueprint, ExtensionBoundary, type ExtensionBoundaryProps, type ExtensionDataContainer, type ExtensionDataRef, type ExtensionDataRefToValue, type ExtensionDataValue, type ExtensionDataValues, type ExtensionDefinition, type ExtensionInput, type ExtensionOverrides, type ExtensionOverridesOptions, type ExternalRouteRef, type FeatureFlagConfig, type FrontendFeature, IconBundleBlueprint, type IconComponent, type IconsApi, type LegacyCreateExtensionOptions, type LegacyExtensionInput, type PluginOptions, type PortableSchema, type ResolvedExtensionInput, type ResolvedExtensionInputs, type RouteFunc, type RouteRef, type RouteResolutionApi, type RouteResolutionApiResolveOptions, type SubRouteRef, analyticsApiRef, appTreeApiRef, componentsApiRef, coreComponentRefs, coreExtensionData, createApiExtension, createAppRootElementExtension, createAppRootWrapperExtension, createComponentExtension, createComponentRef, createExtension, createExtensionBlueprint, createExtensionDataRef, createExtensionInput, createExtensionOverrides, createExternalRouteRef, createNavItemExtension, createNavLogoExtension, createPageExtension, createPlugin, createRouteRef, createRouterExtension, createSchemaFromZod, createSignInPageExtension, createSubRouteRef, createThemeExtension, createTranslationExtension, iconsApiRef, routeResolutionApiRef, useAnalytics, useComponentRef, useRouteRef, useRouteRefParams };

package/dist/index.esm.js

@@ -20,6 +20,7 @@ export { createSignInPageExtension } from './extensions/createSignInPageExtensio
 export { createThemeExtension } from './extensions/createThemeExtension.esm.js';
 export { createComponentExtension } from './extensions/createComponentExtension.esm.js';
 export { createTranslationExtension } from './extensions/createTranslationExtension.esm.js';
+export { IconBundleBlueprint } from './extensions/IconBundleBlueprint.esm.js';
 export { createRouteRef } from './routing/RouteRef.esm.js';
 export { createSubRouteRef } from './routing/SubRouteRef.esm.js';
 export { createExternalRouteRef } from './routing/ExternalRouteRef.esm.js';
@@ -33,4 +34,5 @@ export { createExtensionInput } from './wiring/createExtensionInput.esm.js';
 export { createExtensionDataRef } from './wiring/createExtensionDataRef.esm.js';
 export { createPlugin } from './wiring/createPlugin.esm.js';
 export { createExtensionOverrides } from './wiring/createExtensionOverrides.esm.js';
+export { createExtensionBlueprint } from './wiring/createExtensionBlueprint.esm.js';
 //# sourceMappingURL=index.esm.js.map

package/dist/index.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}