@backstage/plugin-catalog 1.19.0 → 1.19.1-next.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @backstage/plugin-catalog
 
+## 1.19.1-next.0
+
+### Patch Changes
+
+- 5d99272: Update local development dependencies.
+- Updated dependencies
+  - @backstage/core-compat-api@0.2.5-next.0
+  - @backstage/catalog-model@1.5.0-next.0
+  - @backstage/core-components@0.14.5-next.0
+  - @backstage/catalog-client@1.6.5-next.0
+  - @backstage/plugin-catalog-common@1.0.23-next.0
+  - @backstage/plugin-catalog-react@1.11.4-next.0
+  - @backstage/plugin-scaffolder-common@1.5.2-next.0
+  - @backstage/core-plugin-api@1.9.2
+  - @backstage/errors@1.2.4
+  - @backstage/frontend-plugin-api@0.6.5-next.0
+  - @backstage/integration-react@1.1.26
+  - @backstage/types@1.1.1
+  - @backstage/plugin-permission-react@0.4.22
+  - @backstage/plugin-search-common@1.2.11
+  - @backstage/plugin-search-react@1.7.11-next.0
+
 ## 1.19.0
 
 ### Minor Changes

package/alpha/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backstage/plugin-catalog",
-  "version": "1.19.0",
+  "version": "1.19.1-next.0",
   "main": "../dist/alpha.esm.js",
   "module": "../dist/alpha.esm.js",
   "types": "../dist/alpha.d.ts"

package/dist/alpha/EntityOverviewPage.esm.js

@@ -0,0 +1,17 @@
+import { useEntity } from '@backstage/plugin-catalog-react';
+import Grid from '@material-ui/core/Grid';
+import React from 'react';
+import { FilterWrapper } from './filter/FilterWrapper.esm.js';
+import { EntitySwitch } from '../components/EntitySwitch/EntitySwitch.esm.js';
+import { isOrphan, EntityOrphanWarning } from '../components/EntityOrphanWarning/EntityOrphanWarning.esm.js';
+import { hasRelationWarnings, EntityRelationWarning } from '../components/EntityRelationWarning/EntityRelationWarning.esm.js';
+import { hasCatalogProcessingErrors, EntityProcessingErrorsPanel } from '../components/EntityProcessingErrorsPanel/EntityProcessingErrorsPanel.esm.js';
+
+const entityWarningContent = /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(EntitySwitch, null, /* @__PURE__ */ React.createElement(EntitySwitch.Case, { if: isOrphan }, /* @__PURE__ */ React.createElement(Grid, { item: true, xs: 12 }, /* @__PURE__ */ React.createElement(EntityOrphanWarning, null)))), /* @__PURE__ */ React.createElement(EntitySwitch, null, /* @__PURE__ */ React.createElement(EntitySwitch.Case, { if: hasRelationWarnings }, /* @__PURE__ */ React.createElement(Grid, { item: true, xs: 12 }, /* @__PURE__ */ React.createElement(EntityRelationWarning, null)))), /* @__PURE__ */ React.createElement(EntitySwitch, null, /* @__PURE__ */ React.createElement(EntitySwitch.Case, { if: hasCatalogProcessingErrors }, /* @__PURE__ */ React.createElement(Grid, { item: true, xs: 12 }, /* @__PURE__ */ React.createElement(EntityProcessingErrorsPanel, null)))));
+function EntityOverviewPage(props) {
+  const { entity } = useEntity();
+  return /* @__PURE__ */ React.createElement(Grid, { container: true, spacing: 3, alignItems: "stretch" }, entityWarningContent, props.cards.map((card, index) => /* @__PURE__ */ React.createElement(FilterWrapper, { key: index, entity, ...card })));
+}
+
+export { EntityOverviewPage };
+//# sourceMappingURL=EntityOverviewPage.esm.js.map

package/dist/alpha/EntityOverviewPage.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityOverviewPage.esm.js","sources":["../../src/alpha/EntityOverviewPage.tsx"],"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 { Entity } from '@backstage/catalog-model';\nimport { useEntity } from '@backstage/plugin-catalog-react';\nimport Grid from '@material-ui/core/Grid';\nimport React from 'react';\nimport { FilterWrapper } from './filter/FilterWrapper';\nimport { EntitySwitch } from '../components/EntitySwitch';\nimport {\n  EntityOrphanWarning,\n  isOrphan,\n} from '../components/EntityOrphanWarning';\nimport {\n  EntityRelationWarning,\n  hasRelationWarnings,\n} from '../components/EntityRelationWarning';\nimport {\n  EntityProcessingErrorsPanel,\n  hasCatalogProcessingErrors,\n} from '../components/EntityProcessingErrorsPanel';\n\ninterface EntityOverviewPageProps {\n  cards: Array<{\n    element: React.JSX.Element;\n    filterFunction?: (entity: Entity) => boolean;\n    filterExpression?: string;\n  }>;\n}\n\nconst entityWarningContent = (\n  <>\n    <EntitySwitch>\n      <EntitySwitch.Case if={isOrphan}>\n        <Grid item xs={12}>\n          <EntityOrphanWarning />\n        </Grid>\n      </EntitySwitch.Case>\n    </EntitySwitch>\n\n    <EntitySwitch>\n      <EntitySwitch.Case if={hasRelationWarnings}>\n        <Grid item xs={12}>\n          <EntityRelationWarning />\n        </Grid>\n      </EntitySwitch.Case>\n    </EntitySwitch>\n\n    <EntitySwitch>\n      <EntitySwitch.Case if={hasCatalogProcessingErrors}>\n        <Grid item xs={12}>\n          <EntityProcessingErrorsPanel />\n        </Grid>\n      </EntitySwitch.Case>\n    </EntitySwitch>\n  </>\n);\n\nexport function EntityOverviewPage(props: EntityOverviewPageProps) {\n  const { entity } = useEntity();\n  return (\n    <Grid container spacing={3} alignItems=\"stretch\">\n      {entityWarningContent}\n      {props.cards.map((card, index) => (\n        <FilterWrapper key={index} entity={entity} {...card} />\n      ))}\n    </Grid>\n  );\n}\n"],"names":[],"mappings":";;;;;;;;;AA2CA,MAAM,oBACJ,mBAAA,KAAA,CAAA,aAAA,CAAA,KAAA,CAAA,QAAA,EAAA,IAAA,kBACG,KAAA,CAAA,aAAA,CAAA,YAAA,EAAA,IAAA,kBACE,KAAA,CAAA,aAAA,CAAA,YAAA,CAAa,IAAb,EAAA,EAAkB,EAAI,EAAA,QAAA,EAAA,kBACpB,KAAA,CAAA,aAAA,CAAA,IAAA,EAAA,EAAK,IAAI,EAAA,IAAA,EAAC,EAAI,EAAA,EAAA,EAAA,kBACZ,KAAA,CAAA,aAAA,CAAA,mBAAA,EAAA,IAAoB,CACvB,CACF,CACF,CAAA,kBAEC,KAAA,CAAA,aAAA,CAAA,YAAA,EAAA,IAAA,kBACE,KAAA,CAAA,aAAA,CAAA,YAAA,CAAa,IAAb,EAAA,EAAkB,EAAI,EAAA,mBAAA,EAAA,kBACpB,KAAA,CAAA,aAAA,CAAA,IAAA,EAAA,EAAK,IAAI,EAAA,IAAA,EAAC,EAAI,EAAA,EAAA,EAAA,kBACZ,KAAA,CAAA,aAAA,CAAA,qBAAA,EAAA,IAAsB,CACzB,CACF,CACF,CAAA,kBAEC,KAAA,CAAA,aAAA,CAAA,YAAA,EAAA,IAAA,kBACE,KAAA,CAAA,aAAA,CAAA,YAAA,CAAa,IAAb,EAAA,EAAkB,EAAI,EAAA,0BAAA,EAAA,kBACpB,KAAA,CAAA,aAAA,CAAA,IAAA,EAAA,EAAK,IAAI,EAAA,IAAA,EAAC,EAAI,EAAA,EAAA,EAAA,kBACZ,KAAA,CAAA,aAAA,CAAA,2BAAA,EAAA,IAA4B,CAC/B,CACF,CACF,CACF,CAAA,CAAA;AAGK,SAAS,mBAAmB,KAAgC,EAAA;AACjE,EAAM,MAAA,EAAE,MAAO,EAAA,GAAI,SAAU,EAAA,CAAA;AAC7B,EACE,uBAAA,KAAA,CAAA,aAAA,CAAC,QAAK,SAAS,EAAA,IAAA,EAAC,SAAS,CAAG,EAAA,UAAA,EAAW,SACpC,EAAA,EAAA,oBAAA,EACA,KAAM,CAAA,KAAA,CAAM,IAAI,CAAC,IAAA,EAAM,KACtB,qBAAA,KAAA,CAAA,aAAA,CAAC,aAAc,EAAA,EAAA,GAAA,EAAK,OAAO,MAAiB,EAAA,GAAG,IAAM,EAAA,CACtD,CACH,CAAA,CAAA;AAEJ;;;;"}

package/dist/alpha/apis.esm.js

@@ -0,0 +1,35 @@
+import { createApiFactory, discoveryApiRef, fetchApiRef, storageApiRef } from '@backstage/core-plugin-api';
+import { CatalogClient } from '@backstage/catalog-client';
+import { createApiExtension } from '@backstage/frontend-plugin-api';
+import { catalogApiRef, starredEntitiesApiRef, entityPresentationApiRef } from '@backstage/plugin-catalog-react';
+import { DefaultEntityPresentationApi } from '../apis/EntityPresentationApi/DefaultEntityPresentationApi.esm.js';
+import { DefaultStarredEntitiesApi } from '../apis/StarredEntitiesApi/DefaultStarredEntitiesApi.esm.js';
+
+const catalogApi = createApiExtension({
+  factory: createApiFactory({
+    api: catalogApiRef,
+    deps: {
+      discoveryApi: discoveryApiRef,
+      fetchApi: fetchApiRef
+    },
+    factory: ({ discoveryApi, fetchApi }) => new CatalogClient({ discoveryApi, fetchApi })
+  })
+});
+const catalogStarredEntitiesApi = createApiExtension({
+  factory: createApiFactory({
+    api: starredEntitiesApiRef,
+    deps: { storageApi: storageApiRef },
+    factory: ({ storageApi }) => new DefaultStarredEntitiesApi({ storageApi })
+  })
+});
+const entityPresentationApi = createApiExtension({
+  factory: createApiFactory({
+    api: entityPresentationApiRef,
+    deps: { catalogApiImp: catalogApiRef },
+    factory: ({ catalogApiImp }) => DefaultEntityPresentationApi.create({ catalogApi: catalogApiImp })
+  })
+});
+var apis = [catalogApi, catalogStarredEntitiesApi, entityPresentationApi];
+
+export { catalogApi, catalogStarredEntitiesApi, apis as default, entityPresentationApi };
+//# sourceMappingURL=apis.esm.js.map

package/dist/alpha/apis.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apis.esm.js","sources":["../../src/alpha/apis.tsx"],"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 {\n  createApiFactory,\n  discoveryApiRef,\n  fetchApiRef,\n  storageApiRef,\n} from '@backstage/core-plugin-api';\nimport { CatalogClient } from '@backstage/catalog-client';\nimport { createApiExtension } from '@backstage/frontend-plugin-api';\nimport {\n  catalogApiRef,\n  entityPresentationApiRef,\n  starredEntitiesApiRef,\n} from '@backstage/plugin-catalog-react';\nimport {\n  DefaultEntityPresentationApi,\n  DefaultStarredEntitiesApi,\n} from '../apis';\n\nexport const catalogApi = createApiExtension({\n  factory: createApiFactory({\n    api: catalogApiRef,\n    deps: {\n      discoveryApi: discoveryApiRef,\n      fetchApi: fetchApiRef,\n    },\n    factory: ({ discoveryApi, fetchApi }) =>\n      new CatalogClient({ discoveryApi, fetchApi }),\n  }),\n});\n\nexport const catalogStarredEntitiesApi = createApiExtension({\n  factory: createApiFactory({\n    api: starredEntitiesApiRef,\n    deps: { storageApi: storageApiRef },\n    factory: ({ storageApi }) => new DefaultStarredEntitiesApi({ storageApi }),\n  }),\n});\n\nexport const entityPresentationApi = createApiExtension({\n  factory: createApiFactory({\n    api: entityPresentationApiRef,\n    deps: { catalogApiImp: catalogApiRef },\n    factory: ({ catalogApiImp }) =>\n      DefaultEntityPresentationApi.create({ catalogApi: catalogApiImp }),\n  }),\n});\n\nexport default [catalogApi, catalogStarredEntitiesApi, entityPresentationApi];\n"],"names":[],"mappings":";;;;;;;AAkCO,MAAM,aAAa,kBAAmB,CAAA;AAAA,EAC3C,SAAS,gBAAiB,CAAA;AAAA,IACxB,GAAK,EAAA,aAAA;AAAA,IACL,IAAM,EAAA;AAAA,MACJ,YAAc,EAAA,eAAA;AAAA,MACd,QAAU,EAAA,WAAA;AAAA,KACZ;AAAA,IACA,OAAA,EAAS,CAAC,EAAE,YAAc,EAAA,QAAA,EACxB,KAAA,IAAI,aAAc,CAAA,EAAE,YAAc,EAAA,QAAA,EAAU,CAAA;AAAA,GAC/C,CAAA;AACH,CAAC,EAAA;AAEM,MAAM,4BAA4B,kBAAmB,CAAA;AAAA,EAC1D,SAAS,gBAAiB,CAAA;AAAA,IACxB,GAAK,EAAA,qBAAA;AAAA,IACL,IAAA,EAAM,EAAE,UAAA,EAAY,aAAc,EAAA;AAAA,IAClC,OAAA,EAAS,CAAC,EAAE,UAAA,OAAiB,IAAI,yBAAA,CAA0B,EAAE,UAAA,EAAY,CAAA;AAAA,GAC1E,CAAA;AACH,CAAC,EAAA;AAEM,MAAM,wBAAwB,kBAAmB,CAAA;AAAA,EACtD,SAAS,gBAAiB,CAAA;AAAA,IACxB,GAAK,EAAA,wBAAA;AAAA,IACL,IAAA,EAAM,EAAE,aAAA,EAAe,aAAc,EAAA;AAAA,IACrC,OAAA,EAAS,CAAC,EAAE,aAAc,EAAA,KACxB,6BAA6B,MAAO,CAAA,EAAE,UAAY,EAAA,aAAA,EAAe,CAAA;AAAA,GACpE,CAAA;AACH,CAAC,EAAA;AAED,WAAe,CAAC,UAAY,EAAA,yBAAA,EAA2B,qBAAqB,CAAA;;;;"}

package/dist/alpha/createCatalogFilterExtension.esm.js

@@ -0,0 +1,28 @@
+import React, { lazy } from 'react';
+import { createExtension, coreExtensionData, ExtensionBoundary } from '@backstage/frontend-plugin-api';
+
+function createCatalogFilterExtension(options) {
+  var _a;
+  return createExtension({
+    kind: "catalog-filter",
+    namespace: options.namespace,
+    name: options.name,
+    attachTo: { id: "page:catalog", input: "filters" },
+    inputs: (_a = options.inputs) != null ? _a : {},
+    configSchema: options.configSchema,
+    output: {
+      element: coreExtensionData.reactElement
+    },
+    factory({ config, node }) {
+      const ExtensionComponent = lazy(
+        () => options.loader({ config }).then((element) => ({ default: () => element }))
+      );
+      return {
+        element: /* @__PURE__ */ React.createElement(ExtensionBoundary, { node }, /* @__PURE__ */ React.createElement(ExtensionComponent, null))
+      };
+    }
+  });
+}
+
+export { createCatalogFilterExtension };
+//# sourceMappingURL=createCatalogFilterExtension.esm.js.map

package/dist/alpha/createCatalogFilterExtension.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCatalogFilterExtension.esm.js","sources":["../../src/alpha/createCatalogFilterExtension.tsx"],"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 React, { lazy } from 'react';\nimport {\n  AnyExtensionInputMap,\n  ExtensionBoundary,\n  PortableSchema,\n  coreExtensionData,\n  createExtension,\n} from '@backstage/frontend-plugin-api';\n\n/** @alpha */\nexport function createCatalogFilterExtension<\n  TInputs extends AnyExtensionInputMap,\n  TConfig = never,\n>(options: {\n  namespace?: string;\n  name?: string;\n  inputs?: TInputs;\n  configSchema?: PortableSchema<TConfig>;\n  loader: (options: { config: TConfig }) => Promise<JSX.Element>;\n}) {\n  return createExtension({\n    kind: 'catalog-filter',\n    namespace: options.namespace,\n    name: options.name,\n    attachTo: { id: 'page:catalog', input: 'filters' },\n    inputs: options.inputs ?? {},\n    configSchema: options.configSchema,\n    output: {\n      element: coreExtensionData.reactElement,\n    },\n    factory({ config, node }) {\n      const ExtensionComponent = lazy(() =>\n        options\n          .loader({ config })\n          .then(element => ({ default: () => element })),\n      );\n\n      return {\n        element: (\n          <ExtensionBoundary node={node}>\n            <ExtensionComponent />\n          </ExtensionBoundary>\n        ),\n      };\n    },\n  });\n}\n"],"names":[],"mappings":";;;AA0BO,SAAS,6BAGd,OAMC,EAAA;AAnCH,EAAA,IAAA,EAAA,CAAA;AAoCE,EAAA,OAAO,eAAgB,CAAA;AAAA,IACrB,IAAM,EAAA,gBAAA;AAAA,IACN,WAAW,OAAQ,CAAA,SAAA;AAAA,IACnB,MAAM,OAAQ,CAAA,IAAA;AAAA,IACd,QAAU,EAAA,EAAE,EAAI,EAAA,cAAA,EAAgB,OAAO,SAAU,EAAA;AAAA,IACjD,MAAQ,EAAA,CAAA,EAAA,GAAA,OAAA,CAAQ,MAAR,KAAA,IAAA,GAAA,EAAA,GAAkB,EAAC;AAAA,IAC3B,cAAc,OAAQ,CAAA,YAAA;AAAA,IACtB,MAAQ,EAAA;AAAA,MACN,SAAS,iBAAkB,CAAA,YAAA;AAAA,KAC7B;AAAA,IACA,OAAQ,CAAA,EAAE,MAAQ,EAAA,IAAA,EAAQ,EAAA;AACxB,MAAA,MAAM,kBAAqB,GAAA,IAAA;AAAA,QAAK,MAC9B,OAAA,CACG,MAAO,CAAA,EAAE,MAAO,EAAC,CACjB,CAAA,IAAA,CAAK,CAAY,OAAA,MAAA,EAAE,OAAS,EAAA,MAAM,SAAU,CAAA,CAAA;AAAA,OACjD,CAAA;AAEA,MAAO,OAAA;AAAA,QACL,yBACG,KAAA,CAAA,aAAA,CAAA,iBAAA,EAAA,EAAkB,IACjB,EAAA,kBAAA,KAAA,CAAA,aAAA,CAAC,wBAAmB,CACtB,CAAA;AAAA,OAEJ,CAAA;AAAA,KACF;AAAA,GACD,CAAA,CAAA;AACH;;;;"}

package/dist/alpha/entityCards.esm.js

@@ -0,0 +1,74 @@
+import React from 'react';
+import { createEntityCardExtension } from '@backstage/plugin-catalog-react/alpha';
+import { compatWrapper } from '@backstage/core-compat-api';
+
+const catalogAboutEntityCard = createEntityCardExtension({
+  name: "about",
+  loader: async () => import('../components/AboutCard/index.esm.js').then(
+    (m) => compatWrapper(/* @__PURE__ */ React.createElement(m.AboutCard, { variant: "gridItem" }))
+  )
+});
+const catalogLinksEntityCard = createEntityCardExtension({
+  name: "links",
+  filter: "has:links",
+  loader: async () => import('../components/EntityLinksCard/index.esm.js').then(
+    (m) => compatWrapper(/* @__PURE__ */ React.createElement(m.EntityLinksCard, { variant: "gridItem" }))
+  )
+});
+const catalogLabelsEntityCard = createEntityCardExtension({
+  name: "labels",
+  filter: "has:labels",
+  loader: async () => import('../components/EntityLabelsCard/index.esm.js').then(
+    (m) => compatWrapper(/* @__PURE__ */ React.createElement(m.EntityLabelsCard, { variant: "gridItem" }))
+  )
+});
+const catalogDependsOnComponentsEntityCard = createEntityCardExtension({
+  name: "depends-on-components",
+  loader: async () => import('../components/DependsOnComponentsCard/index.esm.js').then(
+    (m) => compatWrapper(/* @__PURE__ */ React.createElement(m.DependsOnComponentsCard, { variant: "gridItem" }))
+  )
+});
+const catalogDependsOnResourcesEntityCard = createEntityCardExtension({
+  name: "depends-on-resources",
+  loader: async () => import('../components/DependsOnResourcesCard/index.esm.js').then(
+    (m) => compatWrapper(/* @__PURE__ */ React.createElement(m.DependsOnResourcesCard, { variant: "gridItem" }))
+  )
+});
+const catalogHasComponentsEntityCard = createEntityCardExtension({
+  name: "has-components",
+  loader: async () => import('../components/HasComponentsCard/index.esm.js').then(
+    (m) => compatWrapper(/* @__PURE__ */ React.createElement(m.HasComponentsCard, { variant: "gridItem" }))
+  )
+});
+const catalogHasResourcesEntityCard = createEntityCardExtension({
+  name: "has-resources",
+  loader: async () => import('../components/HasResourcesCard/index.esm.js').then(
+    (m) => compatWrapper(/* @__PURE__ */ React.createElement(m.HasResourcesCard, { variant: "gridItem" }))
+  )
+});
+const catalogHasSubcomponentsEntityCard = createEntityCardExtension({
+  name: "has-subcomponents",
+  loader: async () => import('../components/HasSubcomponentsCard/index.esm.js').then(
+    (m) => compatWrapper(/* @__PURE__ */ React.createElement(m.HasSubcomponentsCard, { variant: "gridItem" }))
+  )
+});
+const catalogHasSystemsEntityCard = createEntityCardExtension({
+  name: "has-systems",
+  loader: async () => import('../components/HasSystemsCard/index.esm.js').then(
+    (m) => compatWrapper(/* @__PURE__ */ React.createElement(m.HasSystemsCard, { variant: "gridItem" }))
+  )
+});
+var entityCards = [
+  catalogAboutEntityCard,
+  catalogLinksEntityCard,
+  catalogLabelsEntityCard,
+  catalogDependsOnComponentsEntityCard,
+  catalogDependsOnResourcesEntityCard,
+  catalogHasComponentsEntityCard,
+  catalogHasResourcesEntityCard,
+  catalogHasSubcomponentsEntityCard,
+  catalogHasSystemsEntityCard
+];
+
+export { catalogAboutEntityCard, catalogDependsOnComponentsEntityCard, catalogDependsOnResourcesEntityCard, catalogHasComponentsEntityCard, catalogHasResourcesEntityCard, catalogHasSubcomponentsEntityCard, catalogHasSystemsEntityCard, catalogLabelsEntityCard, catalogLinksEntityCard, entityCards as default };
+//# sourceMappingURL=entityCards.esm.js.map

package/dist/alpha/entityCards.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entityCards.esm.js","sources":["../../src/alpha/entityCards.tsx"],"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 React from 'react';\nimport { createEntityCardExtension } from '@backstage/plugin-catalog-react/alpha';\nimport { compatWrapper } from '@backstage/core-compat-api';\n\nexport const catalogAboutEntityCard = createEntityCardExtension({\n  name: 'about',\n  loader: async () =>\n    import('../components/AboutCard').then(m =>\n      compatWrapper(<m.AboutCard variant=\"gridItem\" />),\n    ),\n});\n\nexport const catalogLinksEntityCard = createEntityCardExtension({\n  name: 'links',\n  filter: 'has:links',\n  loader: async () =>\n    import('../components/EntityLinksCard').then(m =>\n      compatWrapper(<m.EntityLinksCard variant=\"gridItem\" />),\n    ),\n});\n\nexport const catalogLabelsEntityCard = createEntityCardExtension({\n  name: 'labels',\n  filter: 'has:labels',\n  loader: async () =>\n    import('../components/EntityLabelsCard').then(m =>\n      compatWrapper(<m.EntityLabelsCard variant=\"gridItem\" />),\n    ),\n});\n\nexport const catalogDependsOnComponentsEntityCard = createEntityCardExtension({\n  name: 'depends-on-components',\n  loader: async () =>\n    import('../components/DependsOnComponentsCard').then(m =>\n      compatWrapper(<m.DependsOnComponentsCard variant=\"gridItem\" />),\n    ),\n});\n\nexport const catalogDependsOnResourcesEntityCard = createEntityCardExtension({\n  name: 'depends-on-resources',\n  loader: async () =>\n    import('../components/DependsOnResourcesCard').then(m =>\n      compatWrapper(<m.DependsOnResourcesCard variant=\"gridItem\" />),\n    ),\n});\n\nexport const catalogHasComponentsEntityCard = createEntityCardExtension({\n  name: 'has-components',\n  loader: async () =>\n    import('../components/HasComponentsCard').then(m =>\n      compatWrapper(<m.HasComponentsCard variant=\"gridItem\" />),\n    ),\n});\n\nexport const catalogHasResourcesEntityCard = createEntityCardExtension({\n  name: 'has-resources',\n  loader: async () =>\n    import('../components/HasResourcesCard').then(m =>\n      compatWrapper(<m.HasResourcesCard variant=\"gridItem\" />),\n    ),\n});\n\nexport const catalogHasSubcomponentsEntityCard = createEntityCardExtension({\n  name: 'has-subcomponents',\n  loader: async () =>\n    import('../components/HasSubcomponentsCard').then(m =>\n      compatWrapper(<m.HasSubcomponentsCard variant=\"gridItem\" />),\n    ),\n});\n\nexport const catalogHasSystemsEntityCard = createEntityCardExtension({\n  name: 'has-systems',\n  loader: async () =>\n    import('../components/HasSystemsCard').then(m =>\n      compatWrapper(<m.HasSystemsCard variant=\"gridItem\" />),\n    ),\n});\n\nexport default [\n  catalogAboutEntityCard,\n  catalogLinksEntityCard,\n  catalogLabelsEntityCard,\n  catalogDependsOnComponentsEntityCard,\n  catalogDependsOnResourcesEntityCard,\n  catalogHasComponentsEntityCard,\n  catalogHasResourcesEntityCard,\n  catalogHasSubcomponentsEntityCard,\n  catalogHasSystemsEntityCard,\n];\n"],"names":[],"mappings":";;;;AAoBO,MAAM,yBAAyB,yBAA0B,CAAA;AAAA,EAC9D,IAAM,EAAA,OAAA;AAAA,EACN,MAAQ,EAAA,YACN,OAAO,sCAAyB,CAAE,CAAA,IAAA;AAAA,IAAK,CAAA,CAAA,KACrC,8BAAe,KAAA,CAAA,aAAA,CAAA,CAAA,CAAE,WAAF,EAAY,OAAA,EAAQ,YAAW,CAAE,CAAA;AAAA,GAClD;AACJ,CAAC,EAAA;AAEM,MAAM,yBAAyB,yBAA0B,CAAA;AAAA,EAC9D,IAAM,EAAA,OAAA;AAAA,EACN,MAAQ,EAAA,WAAA;AAAA,EACR,MAAQ,EAAA,YACN,OAAO,4CAA+B,CAAE,CAAA,IAAA;AAAA,IAAK,CAAA,CAAA,KAC3C,8BAAe,KAAA,CAAA,aAAA,CAAA,CAAA,CAAE,iBAAF,EAAkB,OAAA,EAAQ,YAAW,CAAE,CAAA;AAAA,GACxD;AACJ,CAAC,EAAA;AAEM,MAAM,0BAA0B,yBAA0B,CAAA;AAAA,EAC/D,IAAM,EAAA,QAAA;AAAA,EACN,MAAQ,EAAA,YAAA;AAAA,EACR,MAAQ,EAAA,YACN,OAAO,6CAAgC,CAAE,CAAA,IAAA;AAAA,IAAK,CAAA,CAAA,KAC5C,8BAAe,KAAA,CAAA,aAAA,CAAA,CAAA,CAAE,kBAAF,EAAmB,OAAA,EAAQ,YAAW,CAAE,CAAA;AAAA,GACzD;AACJ,CAAC,EAAA;AAEM,MAAM,uCAAuC,yBAA0B,CAAA;AAAA,EAC5E,IAAM,EAAA,uBAAA;AAAA,EACN,MAAQ,EAAA,YACN,OAAO,oDAAuC,CAAE,CAAA,IAAA;AAAA,IAAK,CAAA,CAAA,KACnD,8BAAe,KAAA,CAAA,aAAA,CAAA,CAAA,CAAE,yBAAF,EAA0B,OAAA,EAAQ,YAAW,CAAE,CAAA;AAAA,GAChE;AACJ,CAAC,EAAA;AAEM,MAAM,sCAAsC,yBAA0B,CAAA;AAAA,EAC3E,IAAM,EAAA,sBAAA;AAAA,EACN,MAAQ,EAAA,YACN,OAAO,mDAAsC,CAAE,CAAA,IAAA;AAAA,IAAK,CAAA,CAAA,KAClD,8BAAe,KAAA,CAAA,aAAA,CAAA,CAAA,CAAE,wBAAF,EAAyB,OAAA,EAAQ,YAAW,CAAE,CAAA;AAAA,GAC/D;AACJ,CAAC,EAAA;AAEM,MAAM,iCAAiC,yBAA0B,CAAA;AAAA,EACtE,IAAM,EAAA,gBAAA;AAAA,EACN,MAAQ,EAAA,YACN,OAAO,8CAAiC,CAAE,CAAA,IAAA;AAAA,IAAK,CAAA,CAAA,KAC7C,8BAAe,KAAA,CAAA,aAAA,CAAA,CAAA,CAAE,mBAAF,EAAoB,OAAA,EAAQ,YAAW,CAAE,CAAA;AAAA,GAC1D;AACJ,CAAC,EAAA;AAEM,MAAM,gCAAgC,yBAA0B,CAAA;AAAA,EACrE,IAAM,EAAA,eAAA;AAAA,EACN,MAAQ,EAAA,YACN,OAAO,6CAAgC,CAAE,CAAA,IAAA;AAAA,IAAK,CAAA,CAAA,KAC5C,8BAAe,KAAA,CAAA,aAAA,CAAA,CAAA,CAAE,kBAAF,EAAmB,OAAA,EAAQ,YAAW,CAAE,CAAA;AAAA,GACzD;AACJ,CAAC,EAAA;AAEM,MAAM,oCAAoC,yBAA0B,CAAA;AAAA,EACzE,IAAM,EAAA,mBAAA;AAAA,EACN,MAAQ,EAAA,YACN,OAAO,iDAAoC,CAAE,CAAA,IAAA;AAAA,IAAK,CAAA,CAAA,KAChD,8BAAe,KAAA,CAAA,aAAA,CAAA,CAAA,CAAE,sBAAF,EAAuB,OAAA,EAAQ,YAAW,CAAE,CAAA;AAAA,GAC7D;AACJ,CAAC,EAAA;AAEM,MAAM,8BAA8B,yBAA0B,CAAA;AAAA,EACnE,IAAM,EAAA,aAAA;AAAA,EACN,MAAQ,EAAA,YACN,OAAO,2CAA8B,CAAE,CAAA,IAAA;AAAA,IAAK,CAAA,CAAA,KAC1C,8BAAe,KAAA,CAAA,aAAA,CAAA,CAAA,CAAE,gBAAF,EAAiB,OAAA,EAAQ,YAAW,CAAE,CAAA;AAAA,GACvD;AACJ,CAAC,EAAA;AAED,kBAAe;AAAA,EACb,sBAAA;AAAA,EACA,sBAAA;AAAA,EACA,uBAAA;AAAA,EACA,oCAAA;AAAA,EACA,mCAAA;AAAA,EACA,8BAAA;AAAA,EACA,6BAAA;AAAA,EACA,iCAAA;AAAA,EACA,2BAAA;AACF,CAAA;;;;"}

package/dist/alpha/entityContents.esm.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { createExtensionInput, coreExtensionData } from '@backstage/frontend-plugin-api';
+import { createEntityContentExtension, catalogExtensionData } from '@backstage/plugin-catalog-react/alpha';
+
+const catalogOverviewEntityContent = createEntityContentExtension({
+  name: "overview",
+  defaultPath: "/",
+  defaultTitle: "Overview",
+  disabled: false,
+  inputs: {
+    cards: createExtensionInput({
+      element: coreExtensionData.reactElement,
+      filterFunction: catalogExtensionData.entityFilterFunction.optional(),
+      filterExpression: catalogExtensionData.entityFilterExpression.optional()
+    })
+  },
+  loader: async ({ inputs }) => import('./EntityOverviewPage.esm.js').then((m) => /* @__PURE__ */ React.createElement(m.EntityOverviewPage, { cards: inputs.cards.map((c) => c.output) }))
+});
+var entityContents = [catalogOverviewEntityContent];
+
+export { catalogOverviewEntityContent, entityContents as default };
+//# sourceMappingURL=entityContents.esm.js.map

package/dist/alpha/entityContents.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entityContents.esm.js","sources":["../../src/alpha/entityContents.tsx"],"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 React from 'react';\nimport {\n  coreExtensionData,\n  createExtensionInput,\n} from '@backstage/frontend-plugin-api';\nimport {\n  createEntityContentExtension,\n  catalogExtensionData,\n} from '@backstage/plugin-catalog-react/alpha';\n\nexport const catalogOverviewEntityContent = createEntityContentExtension({\n  name: 'overview',\n  defaultPath: '/',\n  defaultTitle: 'Overview',\n  disabled: false,\n  inputs: {\n    cards: createExtensionInput({\n      element: coreExtensionData.reactElement,\n      filterFunction: catalogExtensionData.entityFilterFunction.optional(),\n      filterExpression: catalogExtensionData.entityFilterExpression.optional(),\n    }),\n  },\n  loader: async ({ inputs }) =>\n    import('./EntityOverviewPage').then(m => (\n      <m.EntityOverviewPage cards={inputs.cards.map(c => c.output)} />\n    )),\n});\n\nexport default [catalogOverviewEntityContent];\n"],"names":[],"mappings":";;;;AA0BO,MAAM,+BAA+B,4BAA6B,CAAA;AAAA,EACvE,IAAM,EAAA,UAAA;AAAA,EACN,WAAa,EAAA,GAAA;AAAA,EACb,YAAc,EAAA,UAAA;AAAA,EACd,QAAU,EAAA,KAAA;AAAA,EACV,MAAQ,EAAA;AAAA,IACN,OAAO,oBAAqB,CAAA;AAAA,MAC1B,SAAS,iBAAkB,CAAA,YAAA;AAAA,MAC3B,cAAA,EAAgB,oBAAqB,CAAA,oBAAA,CAAqB,QAAS,EAAA;AAAA,MACnE,gBAAA,EAAkB,oBAAqB,CAAA,sBAAA,CAAuB,QAAS,EAAA;AAAA,KACxE,CAAA;AAAA,GACH;AAAA,EACA,MAAA,EAAQ,OAAO,EAAE,MAAA,OACf,OAAO,6BAAsB,CAAE,CAAA,IAAA,CAAK,CAClC,CAAA,qBAAA,KAAA,CAAA,aAAA,CAAC,EAAE,kBAAF,EAAA,EAAqB,OAAO,MAAO,CAAA,KAAA,CAAM,IAAI,CAAK,CAAA,KAAA,CAAA,CAAE,MAAM,CAAA,EAAG,CAC/D,CAAA;AACL,CAAC,EAAA;AAED,qBAAe,CAAC,4BAA4B,CAAA;;;;"}

package/dist/alpha/filter/FilterWrapper.esm.js

@@ -0,0 +1,40 @@
+import Grid from '@material-ui/core/Grid';
+import React, { useMemo } from 'react';
+import { parseFilterExpression } from './parseFilterExpression.esm.js';
+
+const seenParseErrorExpressionStrings = /* @__PURE__ */ new Set();
+const seenDuplicateExpressionStrings = /* @__PURE__ */ new Set();
+function buildFilterFn(filterFunction, filterExpression) {
+  if (filterFunction && filterExpression && !seenDuplicateExpressionStrings.has(filterExpression)) {
+    console.warn(
+      `Duplicate entity filter methods found, both '${filterExpression}' as well as a callback function, which is not permitted - using the callback`
+    );
+    seenDuplicateExpressionStrings.add(filterExpression);
+  }
+  const filter = filterFunction || filterExpression;
+  if (!filter) {
+    return () => true;
+  } else if (typeof filter === "function") {
+    return (subject) => filter(subject);
+  }
+  const result = parseFilterExpression(filter);
+  if (result.expressionParseErrors.length && !seenParseErrorExpressionStrings.has(filter)) {
+    console.warn(
+      `Error(s) in entity filter expression '${filter}'`,
+      result.expressionParseErrors
+    );
+    seenParseErrorExpressionStrings.add(filter);
+  }
+  return result.filterFn;
+}
+function FilterWrapper(props) {
+  const { entity, element, filterFunction, filterExpression } = props;
+  const filterFn = useMemo(
+    () => buildFilterFn(filterFunction, filterExpression),
+    [filterFunction, filterExpression]
+  );
+  return filterFn(entity) ? /* @__PURE__ */ React.createElement(Grid, { item: true, md: 6, xs: 12 }, element) : null;
+}
+
+export { FilterWrapper, buildFilterFn };
+//# sourceMappingURL=FilterWrapper.esm.js.map

package/dist/alpha/filter/FilterWrapper.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterWrapper.esm.js","sources":["../../../src/alpha/filter/FilterWrapper.tsx"],"sourcesContent":["/*\n * Copyright 2024 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 { Entity } from '@backstage/catalog-model';\nimport Grid from '@material-ui/core/Grid';\nimport React, { useMemo } from 'react';\nimport { parseFilterExpression } from './parseFilterExpression';\n\n// Keeps track of what filter expression strings that we've seen duplicates of\n// with functions, or which emitted parsing errors for so far\nconst seenParseErrorExpressionStrings = new Set<string>();\nconst seenDuplicateExpressionStrings = new Set<string>();\n\n// Given an optional filter function and an optional filter expression, make\n// sure that at most one of them was given, and return a filter function that\n// does the right thing.\nexport function buildFilterFn(\n  filterFunction?: (entity: Entity) => boolean,\n  filterExpression?: string,\n): (entity: Entity) => boolean {\n  if (\n    filterFunction &&\n    filterExpression &&\n    !seenDuplicateExpressionStrings.has(filterExpression)\n  ) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      `Duplicate entity filter methods found, both '${filterExpression}' as well as a callback function, which is not permitted - using the callback`,\n    );\n    seenDuplicateExpressionStrings.add(filterExpression);\n  }\n\n  const filter = filterFunction || filterExpression;\n  if (!filter) {\n    return () => true;\n  } else if (typeof filter === 'function') {\n    return subject => filter(subject);\n  }\n\n  const result = parseFilterExpression(filter);\n  if (\n    result.expressionParseErrors.length &&\n    !seenParseErrorExpressionStrings.has(filter)\n  ) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      `Error(s) in entity filter expression '${filter}'`,\n      result.expressionParseErrors,\n    );\n    seenParseErrorExpressionStrings.add(filter);\n  }\n\n  return result.filterFn;\n}\n\n// Handles the memoized parsing of filter expressions\nexport function FilterWrapper(props: {\n  entity: Entity;\n  element: React.JSX.Element;\n  filterFunction?: (entity: Entity) => boolean;\n  filterExpression?: string;\n}) {\n  const { entity, element, filterFunction, filterExpression } = props;\n\n  const filterFn = useMemo(\n    () => buildFilterFn(filterFunction, filterExpression),\n    [filterFunction, filterExpression],\n  );\n\n  return filterFn(entity) ? (\n    <Grid item md={6} xs={12}>\n      {element}\n    </Grid>\n  ) : null;\n}\n"],"names":[],"mappings":";;;;AAuBA,MAAM,+BAAA,uBAAsC,GAAY,EAAA,CAAA;AACxD,MAAM,8BAAA,uBAAqC,GAAY,EAAA,CAAA;AAKvC,SAAA,aAAA,CACd,gBACA,gBAC6B,EAAA;AAC7B,EAAA,IACE,kBACA,gBACA,IAAA,CAAC,8BAA+B,CAAA,GAAA,CAAI,gBAAgB,CACpD,EAAA;AAEA,IAAQ,OAAA,CAAA,IAAA;AAAA,MACN,gDAAgD,gBAAgB,CAAA,6EAAA,CAAA;AAAA,KAClE,CAAA;AACA,IAAA,8BAAA,CAA+B,IAAI,gBAAgB,CAAA,CAAA;AAAA,GACrD;AAEA,EAAA,MAAM,SAAS,cAAkB,IAAA,gBAAA,CAAA;AACjC,EAAA,IAAI,CAAC,MAAQ,EAAA;AACX,IAAA,OAAO,MAAM,IAAA,CAAA;AAAA,GACf,MAAA,IAAW,OAAO,MAAA,KAAW,UAAY,EAAA;AACvC,IAAO,OAAA,CAAA,OAAA,KAAW,OAAO,OAAO,CAAA,CAAA;AAAA,GAClC;AAEA,EAAM,MAAA,MAAA,GAAS,sBAAsB,MAAM,CAAA,CAAA;AAC3C,EAAA,IACE,OAAO,qBAAsB,CAAA,MAAA,IAC7B,CAAC,+BAAgC,CAAA,GAAA,CAAI,MAAM,CAC3C,EAAA;AAEA,IAAQ,OAAA,CAAA,IAAA;AAAA,MACN,yCAAyC,MAAM,CAAA,CAAA,CAAA;AAAA,MAC/C,MAAO,CAAA,qBAAA;AAAA,KACT,CAAA;AACA,IAAA,+BAAA,CAAgC,IAAI,MAAM,CAAA,CAAA;AAAA,GAC5C;AAEA,EAAA,OAAO,MAAO,CAAA,QAAA,CAAA;AAChB,CAAA;AAGO,SAAS,cAAc,KAK3B,EAAA;AACD,EAAA,MAAM,EAAE,MAAA,EAAQ,OAAS,EAAA,cAAA,EAAgB,kBAAqB,GAAA,KAAA,CAAA;AAE9D,EAAA,MAAM,QAAW,GAAA,OAAA;AAAA,IACf,MAAM,aAAc,CAAA,cAAA,EAAgB,gBAAgB,CAAA;AAAA,IACpD,CAAC,gBAAgB,gBAAgB,CAAA;AAAA,GACnC,CAAA;AAEA,EAAA,OAAO,QAAS,CAAA,MAAM,CACpB,mBAAA,KAAA,CAAA,aAAA,CAAC,IAAK,EAAA,EAAA,IAAA,EAAI,IAAC,EAAA,EAAA,EAAI,CAAG,EAAA,EAAA,EAAI,EACnB,EAAA,EAAA,OACH,CACE,GAAA,IAAA,CAAA;AACN;;;;"}

package/dist/alpha/filter/matrchers/createHasMatcher.esm.js

@@ -0,0 +1,31 @@
+import { InputError } from '@backstage/errors';
+
+const allowedMatchers = {
+  labels: (entity) => {
+    var _a;
+    return Object.keys((_a = entity.metadata.labels) != null ? _a : {}).length > 0;
+  },
+  links: (entity) => {
+    var _a;
+    return ((_a = entity.metadata.links) != null ? _a : []).length > 0;
+  }
+};
+function createHasMatcher(parameters, onParseError) {
+  const matchers = parameters.flatMap((parameter) => {
+    const matcher = allowedMatchers[parameter.toLocaleLowerCase("en-US")];
+    if (!matcher) {
+      const known = Object.keys(allowedMatchers).map((m) => `'${m}'`);
+      onParseError(
+        new InputError(
+          `'${parameter}' is not a valid parameter for 'has' filter expressions, expected one of ${known}`
+        )
+      );
+      return [];
+    }
+    return [matcher];
+  });
+  return (entity) => matchers.length ? matchers.some((matcher) => matcher(entity)) : true;
+}
+
+export { createHasMatcher };
+//# sourceMappingURL=createHasMatcher.esm.js.map

package/dist/alpha/filter/matrchers/createHasMatcher.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHasMatcher.esm.js","sources":["../../../../src/alpha/filter/matrchers/createHasMatcher.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 { InputError } from '@backstage/errors';\nimport { EntityMatcherFn } from './types';\n\nconst allowedMatchers: Record<string, EntityMatcherFn> = {\n  labels: entity => {\n    return Object.keys(entity.metadata.labels ?? {}).length > 0;\n  },\n  links: entity => {\n    return (entity.metadata.links ?? []).length > 0;\n  },\n};\n\n/**\n * Matches on the non-empty presence of different parts of the entity\n */\nexport function createHasMatcher(\n  parameters: string[],\n  onParseError: (error: Error) => void,\n): EntityMatcherFn {\n  const matchers = parameters.flatMap(parameter => {\n    const matcher = allowedMatchers[parameter.toLocaleLowerCase('en-US')];\n    if (!matcher) {\n      const known = Object.keys(allowedMatchers).map(m => `'${m}'`);\n      onParseError(\n        new InputError(\n          `'${parameter}' is not a valid parameter for 'has' filter expressions, expected one of ${known}`,\n        ),\n      );\n      return [];\n    }\n    return [matcher];\n  });\n\n  return entity =>\n    matchers.length ? matchers.some(matcher => matcher(entity)) : true;\n}\n"],"names":[],"mappings":";;AAmBA,MAAM,eAAmD,GAAA;AAAA,EACvD,QAAQ,CAAU,MAAA,KAAA;AApBpB,IAAA,IAAA,EAAA,CAAA;AAqBI,IAAO,OAAA,MAAA,CAAO,MAAK,EAAO,GAAA,MAAA,CAAA,QAAA,CAAS,WAAhB,IAA0B,GAAA,EAAA,GAAA,EAAE,CAAA,CAAE,MAAS,GAAA,CAAA,CAAA;AAAA,GAC5D;AAAA,EACA,OAAO,CAAU,MAAA,KAAA;AAvBnB,IAAA,IAAA,EAAA,CAAA;AAwBI,IAAA,OAAA,CAAA,CAAQ,YAAO,QAAS,CAAA,KAAA,KAAhB,IAAyB,GAAA,EAAA,GAAA,IAAI,MAAS,GAAA,CAAA,CAAA;AAAA,GAChD;AACF,CAAA,CAAA;AAKgB,SAAA,gBAAA,CACd,YACA,YACiB,EAAA;AACjB,EAAM,MAAA,QAAA,GAAW,UAAW,CAAA,OAAA,CAAQ,CAAa,SAAA,KAAA;AAC/C,IAAA,MAAM,OAAU,GAAA,eAAA,CAAgB,SAAU,CAAA,iBAAA,CAAkB,OAAO,CAAC,CAAA,CAAA;AACpE,IAAA,IAAI,CAAC,OAAS,EAAA;AACZ,MAAM,MAAA,KAAA,GAAQ,OAAO,IAAK,CAAA,eAAe,EAAE,GAAI,CAAA,CAAA,CAAA,KAAK,CAAI,CAAA,EAAA,CAAC,CAAG,CAAA,CAAA,CAAA,CAAA;AAC5D,MAAA,YAAA;AAAA,QACE,IAAI,UAAA;AAAA,UACF,CAAA,CAAA,EAAI,SAAS,CAAA,yEAAA,EAA4E,KAAK,CAAA,CAAA;AAAA,SAChG;AAAA,OACF,CAAA;AACA,MAAA,OAAO,EAAC,CAAA;AAAA,KACV;AACA,IAAA,OAAO,CAAC,OAAO,CAAA,CAAA;AAAA,GAChB,CAAA,CAAA;AAED,EAAO,OAAA,CAAA,MAAA,KACL,SAAS,MAAS,GAAA,QAAA,CAAS,KAAK,CAAW,OAAA,KAAA,OAAA,CAAQ,MAAM,CAAC,CAAI,GAAA,IAAA,CAAA;AAClE;;;;"}

package/dist/alpha/filter/matrchers/createIsMatcher.esm.js

@@ -0,0 +1,27 @@
+import { InputError } from '@backstage/errors';
+
+const allowedMatchers = {
+  orphan: (entity) => {
+    var _a;
+    return Boolean((_a = entity.metadata.annotations) == null ? void 0 : _a["backstage.io/orphan"]);
+  }
+};
+function createIsMatcher(parameters, onParseError) {
+  const matchers = parameters.flatMap((parameter) => {
+    const matcher = allowedMatchers[parameter.toLocaleLowerCase("en-US")];
+    if (!matcher) {
+      const known = Object.keys(allowedMatchers).map((m) => `'${m}'`);
+      onParseError(
+        new InputError(
+          `'${parameter}' is not a valid parameter for 'is' filter expressions, expected one of ${known}`
+        )
+      );
+      return [];
+    }
+    return [matcher];
+  });
+  return (entity) => matchers.length ? matchers.some((matcher) => matcher(entity)) : true;
+}
+
+export { createIsMatcher };
+//# sourceMappingURL=createIsMatcher.esm.js.map

package/dist/alpha/filter/matrchers/createIsMatcher.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createIsMatcher.esm.js","sources":["../../../../src/alpha/filter/matrchers/createIsMatcher.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 { InputError } from '@backstage/errors';\nimport { EntityMatcherFn } from './types';\n\nconst allowedMatchers: Record<string, EntityMatcherFn> = {\n  orphan: entity =>\n    Boolean(entity.metadata.annotations?.['backstage.io/orphan']),\n};\n\n/**\n * Matches on different semantic properties of the entity\n */\nexport function createIsMatcher(\n  parameters: string[],\n  onParseError: (error: Error) => void,\n): EntityMatcherFn {\n  const matchers = parameters.flatMap(parameter => {\n    const matcher = allowedMatchers[parameter.toLocaleLowerCase('en-US')];\n    if (!matcher) {\n      const known = Object.keys(allowedMatchers).map(m => `'${m}'`);\n      onParseError(\n        new InputError(\n          `'${parameter}' is not a valid parameter for 'is' filter expressions, expected one of ${known}`,\n        ),\n      );\n      return [];\n    }\n    return [matcher];\n  });\n\n  return entity =>\n    matchers.length ? matchers.some(matcher => matcher(entity)) : true;\n}\n"],"names":[],"mappings":";;AAmBA,MAAM,eAAmD,GAAA;AAAA,EACvD,QAAQ,CAAO,MAAA,KAAA;AApBjB,IAAA,IAAA,EAAA,CAAA;AAqBI,IAAA,OAAA,OAAA,CAAA,CAAQ,EAAO,GAAA,MAAA,CAAA,QAAA,CAAS,WAAhB,KAAA,IAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAA8B,qBAAsB,CAAA,CAAA,CAAA;AAAA,GAAA;AAChE,CAAA,CAAA;AAKgB,SAAA,eAAA,CACd,YACA,YACiB,EAAA;AACjB,EAAM,MAAA,QAAA,GAAW,UAAW,CAAA,OAAA,CAAQ,CAAa,SAAA,KAAA;AAC/C,IAAA,MAAM,OAAU,GAAA,eAAA,CAAgB,SAAU,CAAA,iBAAA,CAAkB,OAAO,CAAC,CAAA,CAAA;AACpE,IAAA,IAAI,CAAC,OAAS,EAAA;AACZ,MAAM,MAAA,KAAA,GAAQ,OAAO,IAAK,CAAA,eAAe,EAAE,GAAI,CAAA,CAAA,CAAA,KAAK,CAAI,CAAA,EAAA,CAAC,CAAG,CAAA,CAAA,CAAA,CAAA;AAC5D,MAAA,YAAA;AAAA,QACE,IAAI,UAAA;AAAA,UACF,CAAA,CAAA,EAAI,SAAS,CAAA,wEAAA,EAA2E,KAAK,CAAA,CAAA;AAAA,SAC/F;AAAA,OACF,CAAA;AACA,MAAA,OAAO,EAAC,CAAA;AAAA,KACV;AACA,IAAA,OAAO,CAAC,OAAO,CAAA,CAAA;AAAA,GAChB,CAAA,CAAA;AAED,EAAO,OAAA,CAAA,MAAA,KACL,SAAS,MAAS,GAAA,QAAA,CAAS,KAAK,CAAW,OAAA,KAAA,OAAA,CAAQ,MAAM,CAAC,CAAI,GAAA,IAAA,CAAA;AAClE;;;;"}

package/dist/alpha/filter/matrchers/createKindMatcher.esm.js

@@ -0,0 +1,7 @@
+function createKindMatcher(parameters, _onParseError) {
+  const items = parameters.map((p) => p.toLocaleLowerCase("en-US"));
+  return (entity) => items.includes(entity.kind.toLocaleLowerCase("en-US"));
+}
+
+export { createKindMatcher };
+//# sourceMappingURL=createKindMatcher.esm.js.map

package/dist/alpha/filter/matrchers/createKindMatcher.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createKindMatcher.esm.js","sources":["../../../../src/alpha/filter/matrchers/createKindMatcher.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 { EntityMatcherFn } from './types';\n\n/**\n * Matches on kind\n */\nexport function createKindMatcher(\n  parameters: string[],\n  _onParseError: (error: Error) => void,\n): EntityMatcherFn {\n  const items = parameters.map(p => p.toLocaleLowerCase('en-US'));\n  return entity => items.includes(entity.kind.toLocaleLowerCase('en-US'));\n}\n"],"names":[],"mappings":"AAqBgB,SAAA,iBAAA,CACd,YACA,aACiB,EAAA;AACjB,EAAA,MAAM,QAAQ,UAAW,CAAA,GAAA,CAAI,OAAK,CAAE,CAAA,iBAAA,CAAkB,OAAO,CAAC,CAAA,CAAA;AAC9D,EAAA,OAAO,YAAU,KAAM,CAAA,QAAA,CAAS,OAAO,IAAK,CAAA,iBAAA,CAAkB,OAAO,CAAC,CAAA,CAAA;AACxE;;;;"}

package/dist/alpha/filter/matrchers/createTypeMatcher.esm.js

@@ -0,0 +1,11 @@
+function createTypeMatcher(parameters, _onParseError) {
+  const items = parameters.map((p) => p.toLocaleLowerCase("en-US"));
+  return (entity) => {
+    var _a;
+    const value = (_a = entity.spec) == null ? void 0 : _a.type;
+    return typeof value === "string" && items.includes(value.toLocaleLowerCase("en-US"));
+  };
+}
+
+export { createTypeMatcher };
+//# sourceMappingURL=createTypeMatcher.esm.js.map

package/dist/alpha/filter/matrchers/createTypeMatcher.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeMatcher.esm.js","sources":["../../../../src/alpha/filter/matrchers/createTypeMatcher.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 { EntityMatcherFn } from './types';\n\n/**\n * Matches on spec.type\n */\nexport function createTypeMatcher(\n  parameters: string[],\n  _onParseError: (error: Error) => void,\n): EntityMatcherFn {\n  const items = parameters.map(p => p.toLocaleLowerCase('en-US'));\n  return entity => {\n    const value = entity.spec?.type;\n    return (\n      typeof value === 'string' &&\n      items.includes(value.toLocaleLowerCase('en-US'))\n    );\n  };\n}\n"],"names":[],"mappings":"AAqBgB,SAAA,iBAAA,CACd,YACA,aACiB,EAAA;AACjB,EAAA,MAAM,QAAQ,UAAW,CAAA,GAAA,CAAI,OAAK,CAAE,CAAA,iBAAA,CAAkB,OAAO,CAAC,CAAA,CAAA;AAC9D,EAAA,OAAO,CAAU,MAAA,KAAA;AA1BnB,IAAA,IAAA,EAAA,CAAA;AA2BI,IAAM,MAAA,KAAA,GAAA,CAAQ,EAAO,GAAA,MAAA,CAAA,IAAA,KAAP,IAAa,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,IAAA,CAAA;AAC3B,IACE,OAAA,OAAO,UAAU,QACjB,IAAA,KAAA,CAAM,SAAS,KAAM,CAAA,iBAAA,CAAkB,OAAO,CAAC,CAAA,CAAA;AAAA,GAEnD,CAAA;AACF;;;;"}

package/dist/alpha/filter/parseFilterExpression.esm.js

@@ -0,0 +1,69 @@
+import { InputError } from '@backstage/errors';
+import { createKindMatcher } from './matrchers/createKindMatcher.esm.js';
+import { createTypeMatcher } from './matrchers/createTypeMatcher.esm.js';
+import { createIsMatcher } from './matrchers/createIsMatcher.esm.js';
+import { createHasMatcher } from './matrchers/createHasMatcher.esm.js';
+
+const rootMatcherFactories = {
+  kind: createKindMatcher,
+  type: createTypeMatcher,
+  is: createIsMatcher,
+  has: createHasMatcher
+};
+function parseFilterExpression(expression) {
+  const expressionParseErrors = [];
+  const parts = splitFilterExpression(
+    expression,
+    (e) => expressionParseErrors.push(e)
+  );
+  const matchers = parts.flatMap((part) => {
+    const factory = rootMatcherFactories[part.key];
+    if (!factory) {
+      const known = Object.keys(rootMatcherFactories).map((m) => `'${m}'`);
+      expressionParseErrors.push(
+        new InputError(
+          `'${part.key}' is not a valid filter expression key, expected one of ${known}`
+        )
+      );
+      return [];
+    }
+    const matcher = factory(
+      part.parameters,
+      (e) => expressionParseErrors.push(e)
+    );
+    return [matcher];
+  });
+  const filterFn = (entity) => matchers.every((matcher) => {
+    try {
+      return matcher(entity);
+    } catch {
+      return false;
+    }
+  });
+  return {
+    filterFn,
+    expressionParseErrors
+  };
+}
+function splitFilterExpression(expression, onParseError) {
+  const words = expression.split(" ").map((w) => w.trim()).filter(Boolean);
+  const result = new Array();
+  for (const word of words) {
+    const match = word.match(/^([^:]+):(.+)$/);
+    if (!match) {
+      onParseError(
+        new InputError(
+          `'${word}' is not a valid filter expression, expected 'key:parameter' form`
+        )
+      );
+      continue;
+    }
+    const key = match[1];
+    const parameters = match[2].split(",").filter(Boolean);
+    result.push({ key, parameters });
+  }
+  return result;
+}
+
+export { parseFilterExpression, splitFilterExpression };
+//# sourceMappingURL=parseFilterExpression.esm.js.map

package/dist/alpha/filter/parseFilterExpression.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseFilterExpression.esm.js","sources":["../../../src/alpha/filter/parseFilterExpression.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 { Entity } from '@backstage/catalog-model';\nimport { InputError } from '@backstage/errors';\nimport { EntityMatcherFn } from './matrchers/types';\nimport { createKindMatcher } from './matrchers/createKindMatcher';\nimport { createTypeMatcher } from './matrchers/createTypeMatcher';\nimport { createIsMatcher } from './matrchers/createIsMatcher';\nimport { createHasMatcher } from './matrchers/createHasMatcher';\n\nconst rootMatcherFactories: Record<\n  string,\n  (\n    parameters: string[],\n    onParseError: (error: Error) => void,\n  ) => EntityMatcherFn\n> = {\n  kind: createKindMatcher,\n  type: createTypeMatcher,\n  is: createIsMatcher,\n  has: createHasMatcher,\n};\n\n/**\n * Parses a filter expression that decides whether to render an entity component\n * or not. Returns a function that matches entities based on that expression.\n *\n * @remarks\n *\n * Filter strings are on the form `kind:user,group is:orphan`. There's\n * effectively an AND between the space separated parts, and an OR between comma\n * separated parameters. So the example filter string semantically means\n * \"entities that are of either User or Group kind, and also are orphans\".\n *\n * The `expressionParseErrors` array contains any errors that were encountered\n * during initial parsing of the expression. Note that the parts of the input\n * expression that had errors are ignored entirely and parsing continues as if\n * they didn't exist.\n */\nexport function parseFilterExpression(expression: string): {\n  filterFn: (entity: Entity) => boolean;\n  expressionParseErrors: Error[];\n} {\n  const expressionParseErrors: Error[] = [];\n\n  const parts = splitFilterExpression(expression, e =>\n    expressionParseErrors.push(e),\n  );\n\n  const matchers = parts.flatMap(part => {\n    const factory = rootMatcherFactories[part.key];\n    if (!factory) {\n      const known = Object.keys(rootMatcherFactories).map(m => `'${m}'`);\n      expressionParseErrors.push(\n        new InputError(\n          `'${part.key}' is not a valid filter expression key, expected one of ${known}`,\n        ),\n      );\n      return [];\n    }\n\n    const matcher = factory(part.parameters, e =>\n      expressionParseErrors.push(e),\n    );\n    return [matcher];\n  });\n\n  const filterFn = (entity: Entity) =>\n    matchers.every(matcher => {\n      try {\n        return matcher(entity);\n      } catch {\n        return false;\n      }\n    });\n\n  return {\n    filterFn,\n    expressionParseErrors,\n  };\n}\n\nexport function splitFilterExpression(\n  expression: string,\n  onParseError: (error: Error) => void,\n): Array<{ key: string; parameters: string[] }> {\n  const words = expression\n    .split(' ')\n    .map(w => w.trim())\n    .filter(Boolean);\n\n  const result = new Array<{ key: string; parameters: string[] }>();\n\n  for (const word of words) {\n    const match = word.match(/^([^:]+):(.+)$/);\n    if (!match) {\n      onParseError(\n        new InputError(\n          `'${word}' is not a valid filter expression, expected 'key:parameter' form`,\n        ),\n      );\n      continue;\n    }\n\n    const key = match[1];\n    const parameters = match[2].split(',').filter(Boolean); // silently ignore double commas\n\n    result.push({ key, parameters });\n  }\n\n  return result;\n}\n"],"names":[],"mappings":";;;;;;AAwBA,MAAM,oBAMF,GAAA;AAAA,EACF,IAAM,EAAA,iBAAA;AAAA,EACN,IAAM,EAAA,iBAAA;AAAA,EACN,EAAI,EAAA,eAAA;AAAA,EACJ,GAAK,EAAA,gBAAA;AACP,CAAA,CAAA;AAkBO,SAAS,sBAAsB,UAGpC,EAAA;AACA,EAAA,MAAM,wBAAiC,EAAC,CAAA;AAExC,EAAA,MAAM,KAAQ,GAAA,qBAAA;AAAA,IAAsB,UAAA;AAAA,IAAY,CAAA,CAAA,KAC9C,qBAAsB,CAAA,IAAA,CAAK,CAAC,CAAA;AAAA,GAC9B,CAAA;AAEA,EAAM,MAAA,QAAA,GAAW,KAAM,CAAA,OAAA,CAAQ,CAAQ,IAAA,KAAA;AACrC,IAAM,MAAA,OAAA,GAAU,oBAAqB,CAAA,IAAA,CAAK,GAAG,CAAA,CAAA;AAC7C,IAAA,IAAI,CAAC,OAAS,EAAA;AACZ,MAAM,MAAA,KAAA,GAAQ,OAAO,IAAK,CAAA,oBAAoB,EAAE,GAAI,CAAA,CAAA,CAAA,KAAK,CAAI,CAAA,EAAA,CAAC,CAAG,CAAA,CAAA,CAAA,CAAA;AACjE,MAAsB,qBAAA,CAAA,IAAA;AAAA,QACpB,IAAI,UAAA;AAAA,UACF,CAAI,CAAA,EAAA,IAAA,CAAK,GAAG,CAAA,wDAAA,EAA2D,KAAK,CAAA,CAAA;AAAA,SAC9E;AAAA,OACF,CAAA;AACA,MAAA,OAAO,EAAC,CAAA;AAAA,KACV;AAEA,IAAA,MAAM,OAAU,GAAA,OAAA;AAAA,MAAQ,IAAK,CAAA,UAAA;AAAA,MAAY,CAAA,CAAA,KACvC,qBAAsB,CAAA,IAAA,CAAK,CAAC,CAAA;AAAA,KAC9B,CAAA;AACA,IAAA,OAAO,CAAC,OAAO,CAAA,CAAA;AAAA,GAChB,CAAA,CAAA;AAED,EAAA,MAAM,QAAW,GAAA,CAAC,MAChB,KAAA,QAAA,CAAS,MAAM,CAAW,OAAA,KAAA;AACxB,IAAI,IAAA;AACF,MAAA,OAAO,QAAQ,MAAM,CAAA,CAAA;AAAA,KACf,CAAA,MAAA;AACN,MAAO,OAAA,KAAA,CAAA;AAAA,KACT;AAAA,GACD,CAAA,CAAA;AAEH,EAAO,OAAA;AAAA,IACL,QAAA;AAAA,IACA,qBAAA;AAAA,GACF,CAAA;AACF,CAAA;AAEgB,SAAA,qBAAA,CACd,YACA,YAC8C,EAAA;AAC9C,EAAA,MAAM,KAAQ,GAAA,UAAA,CACX,KAAM,CAAA,GAAG,CACT,CAAA,GAAA,CAAI,CAAK,CAAA,KAAA,CAAA,CAAE,IAAK,EAAC,CACjB,CAAA,MAAA,CAAO,OAAO,CAAA,CAAA;AAEjB,EAAM,MAAA,MAAA,GAAS,IAAI,KAA6C,EAAA,CAAA;AAEhE,EAAA,KAAA,MAAW,QAAQ,KAAO,EAAA;AACxB,IAAM,MAAA,KAAA,GAAQ,IAAK,CAAA,KAAA,CAAM,gBAAgB,CAAA,CAAA;AACzC,IAAA,IAAI,CAAC,KAAO,EAAA;AACV,MAAA,YAAA;AAAA,QACE,IAAI,UAAA;AAAA,UACF,IAAI,IAAI,CAAA,iEAAA,CAAA;AAAA,SACV;AAAA,OACF,CAAA;AACA,MAAA,SAAA;AAAA,KACF;AAEA,IAAM,MAAA,GAAA,GAAM,MAAM,CAAC,CAAA,CAAA;AACnB,IAAM,MAAA,UAAA,GAAa,MAAM,CAAC,CAAA,CAAE,MAAM,GAAG,CAAA,CAAE,OAAO,OAAO,CAAA,CAAA;AAErD,IAAA,MAAA,CAAO,IAAK,CAAA,EAAE,GAAK,EAAA,UAAA,EAAY,CAAA,CAAA;AAAA,GACjC;AAEA,EAAO,OAAA,MAAA,CAAA;AACT;;;;"}

package/dist/alpha/filters.esm.js

@@ -0,0 +1,88 @@
+import React from 'react';
+import { createCatalogFilterExtension } from './createCatalogFilterExtension.esm.js';
+import { createSchemaFromZod } from '@backstage/frontend-plugin-api';
+
+const catalogTagCatalogFilter = createCatalogFilterExtension({
+  name: "tag",
+  loader: async () => {
+    const { EntityTagPicker } = await import('@backstage/plugin-catalog-react');
+    return /* @__PURE__ */ React.createElement(EntityTagPicker, null);
+  }
+});
+const catalogKindCatalogFilter = createCatalogFilterExtension({
+  name: "kind",
+  configSchema: createSchemaFromZod(
+    (z) => z.object({
+      initialFilter: z.string().default("component")
+    })
+  ),
+  loader: async ({ config }) => {
+    const { EntityKindPicker } = await import('@backstage/plugin-catalog-react');
+    return /* @__PURE__ */ React.createElement(EntityKindPicker, { initialFilter: config.initialFilter });
+  }
+});
+const catalogTypeCatalogFilter = createCatalogFilterExtension({
+  name: "type",
+  loader: async () => {
+    const { EntityTypePicker } = await import('@backstage/plugin-catalog-react');
+    return /* @__PURE__ */ React.createElement(EntityTypePicker, null);
+  }
+});
+const catalogModeCatalogFilter = createCatalogFilterExtension({
+  name: "mode",
+  configSchema: createSchemaFromZod(
+    (z) => z.object({
+      mode: z.enum(["owners-only", "all"]).optional()
+    })
+  ),
+  loader: async ({ config }) => {
+    const { EntityOwnerPicker } = await import('@backstage/plugin-catalog-react');
+    return /* @__PURE__ */ React.createElement(EntityOwnerPicker, { mode: config.mode });
+  }
+});
+const catalogNamespaceCatalogFilter = createCatalogFilterExtension({
+  name: "namespace",
+  loader: async () => {
+    const { EntityNamespacePicker } = await import('@backstage/plugin-catalog-react');
+    return /* @__PURE__ */ React.createElement(EntityNamespacePicker, null);
+  }
+});
+const catalogLifecycleCatalogFilter = createCatalogFilterExtension({
+  name: "lifecycle",
+  loader: async () => {
+    const { EntityLifecyclePicker } = await import('@backstage/plugin-catalog-react');
+    return /* @__PURE__ */ React.createElement(EntityLifecyclePicker, null);
+  }
+});
+const catalogProcessingStatusCatalogFilter = createCatalogFilterExtension({
+  name: "processing-status",
+  loader: async () => {
+    const { EntityProcessingStatusPicker } = await import('@backstage/plugin-catalog-react');
+    return /* @__PURE__ */ React.createElement(EntityProcessingStatusPicker, null);
+  }
+});
+const catalogListCatalogFilter = createCatalogFilterExtension({
+  name: "list",
+  configSchema: createSchemaFromZod(
+    (z) => z.object({
+      initialFilter: z.enum(["owned", "starred", "all"]).default("owned")
+    })
+  ),
+  loader: async ({ config }) => {
+    const { UserListPicker } = await import('@backstage/plugin-catalog-react');
+    return /* @__PURE__ */ React.createElement(UserListPicker, { initialFilter: config.initialFilter });
+  }
+});
+var filters = [
+  catalogTagCatalogFilter,
+  catalogKindCatalogFilter,
+  catalogTypeCatalogFilter,
+  catalogModeCatalogFilter,
+  catalogNamespaceCatalogFilter,
+  catalogLifecycleCatalogFilter,
+  catalogProcessingStatusCatalogFilter,
+  catalogListCatalogFilter
+];
+
+export { filters as default };
+//# sourceMappingURL=filters.esm.js.map