@alauda-fe/common 1.4.28-beta.1 → 1.4.28-beta.3

package/esm2022/code/yaml-sidebar/yaml-examples.mjs

@@ -0,0 +1,340 @@
+/**
+ * Kubernetes 资源的内置 YAML 示例
+ * 按照 apiVersion.kind 的格式组织
+ */
+export const BUILT_IN_YAML_EXAMPLES = {
+    'apps/v1.Deployment': [
+        {
+            title: 'Basic Deployment',
+            description: 'A basic deployment example with nginx container',
+            yaml: `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: example
+spec:
+  selector:
+    matchLabels:
+      app: httpd
+  replicas: 3
+  template:
+    metadata:
+      labels:
+        app: httpd
+    spec:
+      containers:
+      - name: httpd
+        image: internal-docker-registry.cpaas-system.svc/demo-ns/nginx:alpine
+        ports:
+        - containerPort: 8080`,
+        },
+    ],
+    'v1.ConfigMap': [
+        {
+            title: 'Basic ConfigMap',
+            description: 'A basic ConfigMap example with properties and file data',
+            yaml: `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: example
+  namespace: default
+data:
+  example.property.1: hello
+  example.property.2: world
+  example.property.file: |-
+    property.1=value-1
+    property.2=value-2
+    property.3=value-3`,
+        },
+    ],
+    'batch/v1.CronJob': [
+        {
+            title: 'Basic CronJob',
+            description: 'A basic CronJob example that runs daily',
+            yaml: `apiVersion: batch/v1
+kind: CronJob
+metadata:
+  name: example
+spec:
+  schedule: "@daily"
+  jobTemplate:
+    spec:
+      template:
+        spec:
+          containers:
+          - name: hello
+            image: busybox
+            args:
+            - /bin/sh
+            - -c
+            - date; echo Hello from the Kubernetes cluster
+          restartPolicy: OnFailure`,
+        },
+    ],
+    'v1.PersistentVolume': [
+        {
+            title: 'Basic PersistentVolume',
+            description: 'A basic PersistentVolume example with NFS storage',
+            yaml: `apiVersion: v1
+kind: PersistentVolume
+metadata:
+  name: example
+spec:
+  capacity:
+    storage: 5Gi
+  accessModes:
+    - ReadWriteOnce
+  persistentVolumeReclaimPolicy: Retain
+  storageClassName: slow
+  nfs:
+    path: /tmp
+    server: 172.17.0.2`,
+        },
+    ],
+    'autoscaling/v2.HorizontalPodAutoscaler': [
+        {
+            title: 'Basic HorizontalPodAutoscaler',
+            description: 'A basic HPA example with CPU utilization target',
+            yaml: `apiVersion: autoscaling/v2
+kind: HorizontalPodAutoscaler
+metadata:
+  name: example
+spec:
+  scaleTargetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: example
+  minReplicas: 1
+  maxReplicas: 3
+  metrics:
+  - type: Resource
+    resource:
+      name: cpu
+      target:
+        averageUtilization: 50
+        type: Utilization`,
+        },
+    ],
+    'apps/v1.DaemonSet': [
+        {
+            title: 'Basic DaemonSet',
+            description: 'A basic DaemonSet example with nginx container',
+            yaml: `apiVersion: apps/v1
+kind: DaemonSet
+metadata:
+  name: example
+spec:
+  selector:
+    matchLabels:
+      app: httpd
+  template:
+    metadata:
+      labels:
+        app: httpd
+    spec:
+      containers:
+      - name: httpd
+        image: internal-docker-registry.cpaas-system.svc/demo-ns/nginx:alpine
+        ports:
+        - containerPort: 8080`,
+        },
+    ],
+    'v1.PersistentVolumeClaim': [
+        {
+            title: 'Basic PersistentVolumeClaim',
+            description: 'A basic PVC example requesting 1Gi storage',
+            yaml: `apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: example
+spec:
+  accessModes:
+    - ReadWriteOnce
+  volumeMode: Filesystem
+  resources:
+    requests:
+      storage: 1Gi`,
+        },
+    ],
+    'v1.ResourceQuota': [
+        {
+            title: 'Compute ResourceQuota',
+            description: 'A ResourceQuota example for compute resources',
+            yaml: `apiVersion: v1
+kind: ResourceQuota
+metadata:
+  name: compute-quota
+  namespace: default
+spec:
+  hard:
+    requests.cpu: '1'
+    requests.memory: 1Gi
+    limits.cpu: '2'
+    limits.memory: 2Gi`,
+        },
+        {
+            title: 'Storage Class ResourceQuota',
+            description: 'A ResourceQuota example for storage class specific quotas',
+            yaml: `apiVersion: v1
+kind: ResourceQuota
+metadata:
+  name: storage-class-quota
+  namespace: default
+spec:
+  hard:
+    requests.storage: 100Gi
+    persistentvolumeclaims: '100'
+    # For quota specific to a storage class, the storage class must have the same name
+    gold.storage-class.kubernetes.io/requests.storage: 3Gi
+    gold.storage-class.kubernetes.io/persistentvolumeclaims: '5'
+    silver.storage-class.kubernetes.io/requests.storage: 2Gi
+    silver.storage-class.kubernetes.io/persistentvolumeclaims: '3'
+    bronze.storage-class.kubernetes.io/requests.storage: 1Gi
+    bronze.storage-class.kubernetes.io/persistentvolumeclaims: '1'`,
+        },
+        {
+            title: 'Object Counts ResourceQuota',
+            description: 'A ResourceQuota example for object count limits',
+            yaml: `apiVersion: v1
+kind: ResourceQuota
+metadata:
+  name: object-counts
+  namespace: default
+spec:
+  hard:
+    configmaps: "10"
+    persistentvolumeclaims: "4"
+    replicationcontrollers: "20"
+    secrets: "10"
+    services: "10"
+    services.loadbalancers: "2"`,
+        },
+    ],
+    'v1.LimitRange': [
+        {
+            title: 'Memory LimitRange',
+            description: 'A LimitRange example for container memory limits',
+            yaml: `apiVersion: v1
+kind: LimitRange
+metadata:
+  name: mem-limit-range
+spec:
+  limits:
+  - default:
+      memory: 512Mi
+    defaultRequest:
+      memory: 256Mi
+    type: Container`,
+        },
+    ],
+    'apps/v1.StatefulSet': [
+        {
+            title: 'Basic StatefulSet',
+            description: 'A basic StatefulSet example with persistent storage',
+            yaml: `apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: example
+spec:
+  serviceName: "httpd"
+  replicas: 3
+  selector:
+    matchLabels:
+      app: httpd
+  template:
+    metadata:
+      labels:
+        app: httpd
+    spec:
+      terminationGracePeriodSeconds: 10
+      containers:
+      - name: httpd
+        image: internal-docker-registry.cpaas-system.svc/demo-ns/nginx:alpine
+        ports:
+        - containerPort: 8080
+          name: web
+        volumeMounts:
+        - name: www
+          mountPath: /var/www/html
+  volumeClaimTemplates:
+  - metadata:
+      name: www
+    spec:
+      accessModes: [ "ReadWriteOnce" ]
+      storageClassName: my-storage-class
+      resources:
+        requests:
+          storage: 1Gi`,
+        },
+    ],
+    'storage.k8s.io/v1.StorageClass': [
+        {
+            title: 'Basic StorageClass',
+            description: 'A basic StorageClass example',
+            yaml: `apiVersion: storage.k8s.io/v1
+kind: StorageClass
+metadata:
+  name: example
+provisioner: my-provisioner
+reclaimPolicy: Delete`,
+        },
+    ],
+    'v1.Secret': [
+        {
+            title: 'Basic Secret',
+            description: 'A basic Secret example with username and password',
+            yaml: `apiVersion: v1
+kind: Secret
+metadata:
+  name: example
+type: Opaque
+stringData:
+  username: admin
+  password: opensesame`,
+        },
+    ],
+    'app.k8s.io/v1beta1.Application': [
+        {
+            title: 'Basic Application',
+            description: 'A basic Application example with Deployment and Service',
+            yaml: `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  labels:
+    app: nginx
+  name: nginx-deployment
+  namespace: yintest-ns1
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: nginx
+  template:
+    metadata:
+      labels:
+        app: nginx
+    spec:
+      containers:
+        - image: nginx:1.7.9
+          name: nginx
+          ports:
+            - containerPort: 80
+---
+apiVersion: v1
+kind: Service
+metadata:
+  labels:
+    app: nginx
+  name: nginx
+  namespace: yintest-ns1
+spec:
+  ports:
+    - port: 80
+      protocol: TCP
+      targetPort: 80
+  selector:
+    app: nginx
+  type: ClusterIP`,
+        },
+    ],
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yaml-examples.js","sourceRoot":"","sources":["../../../../../../libs/common/src/code/yaml-sidebar/yaml-examples.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAqC;IACtE,oBAAoB,EAAE;QACpB;YACE,KAAK,EAAE,kBAAkB;YACzB,WAAW,EAAE,iDAAiD;YAC9D,IAAI,EAAE;;;;;;;;;;;;;;;;;;8BAkBkB;SACzB;KACF;IAED,cAAc,EAAE;QACd;YACE,KAAK,EAAE,iBAAiB;YACxB,WAAW,EAAE,yDAAyD;YACtE,IAAI,EAAE;;;;;;;;;;;uBAWW;SAClB;KACF;IAED,kBAAkB,EAAE;QAClB;YACE,KAAK,EAAE,eAAe;YACtB,WAAW,EAAE,yCAAyC;YACtD,IAAI,EAAE;;;;;;;;;;;;;;;;;mCAiBuB;SAC9B;KACF;IAED,qBAAqB,EAAE;QACrB;YACE,KAAK,EAAE,wBAAwB;YAC/B,WAAW,EAAE,mDAAmD;YAChE,IAAI,EAAE;;;;;;;;;;;;;uBAaW;SAClB;KACF;IAED,wCAAwC,EAAE;QACxC;YACE,KAAK,EAAE,+BAA+B;YACtC,WAAW,EAAE,iDAAiD;YAC9D,IAAI,EAAE;;;;;;;;;;;;;;;;;0BAiBc;SACrB;KACF;IAED,mBAAmB,EAAE;QACnB;YACE,KAAK,EAAE,iBAAiB;YACxB,WAAW,EAAE,gDAAgD;YAC7D,IAAI,EAAE;;;;;;;;;;;;;;;;;8BAiBkB;SACzB;KACF;IAED,0BAA0B,EAAE;QAC1B;YACE,KAAK,EAAE,6BAA6B;YACpC,WAAW,EAAE,4CAA4C;YACzD,IAAI,EAAE;;;;;;;;;;mBAUO;SACd;KACF;IAED,kBAAkB,EAAE;QAClB;YACE,KAAK,EAAE,uBAAuB;YAC9B,WAAW,EAAE,+CAA+C;YAC5D,IAAI,EAAE;;;;;;;;;;uBAUW;SAClB;QACD;YACE,KAAK,EAAE,6BAA6B;YACpC,WAAW,EAAE,2DAA2D;YACxE,IAAI,EAAE;;;;;;;;;;;;;;;mEAeuD;SAC9D;QACD;YACE,KAAK,EAAE,6BAA6B;YACpC,WAAW,EAAE,iDAAiD;YAC9D,IAAI,EAAE;;;;;;;;;;;;gCAYoB;SAC3B;KACF;IAED,eAAe,EAAE;QACf;YACE,KAAK,EAAE,mBAAmB;YAC1B,WAAW,EAAE,kDAAkD;YAC/D,IAAI,EAAE;;;;;;;;;;oBAUQ;SACf;KACF;IAED,qBAAqB,EAAE;QACrB;YACE,KAAK,EAAE,mBAAmB;YAC1B,WAAW,EAAE,qDAAqD;YAClE,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiCW;SAClB;KACF;IAED,gCAAgC,EAAE;QAChC;YACE,KAAK,EAAE,oBAAoB;YAC3B,WAAW,EAAE,8BAA8B;YAC3C,IAAI,EAAE;;;;;sBAKU;SACjB;KACF;IAED,WAAW,EAAE;QACX;YACE,KAAK,EAAE,cAAc;YACrB,WAAW,EAAE,mDAAmD;YAChE,IAAI,EAAE;;;;;;;uBAOW;SAClB;KACF;IAED,gCAAgC,EAAE;QAChC;YACE,KAAK,EAAE,mBAAmB;YAC1B,WAAW,EAAE,yDAAyD;YACtE,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqCM;SACb;KACF;CACF,CAAC","sourcesContent":["import { YamlExample } from './types';\n\n/**\n * Kubernetes 资源的内置 YAML 示例\n * 按照 apiVersion.kind 的格式组织\n */\nexport const BUILT_IN_YAML_EXAMPLES: { [key: string]: YamlExample[] } = {\n  'apps/v1.Deployment': [\n    {\n      title: 'Basic Deployment',\n      description: 'A basic deployment example with nginx container',\n      yaml: `apiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: example\nspec:\n  selector:\n    matchLabels:\n      app: httpd\n  replicas: 3\n  template:\n    metadata:\n      labels:\n        app: httpd\n    spec:\n      containers:\n      - name: httpd\n        image: internal-docker-registry.cpaas-system.svc/demo-ns/nginx:alpine\n        ports:\n        - containerPort: 8080`,\n    },\n  ],\n\n  'v1.ConfigMap': [\n    {\n      title: 'Basic ConfigMap',\n      description: 'A basic ConfigMap example with properties and file data',\n      yaml: `apiVersion: v1\nkind: ConfigMap\nmetadata:\n  name: example\n  namespace: default\ndata:\n  example.property.1: hello\n  example.property.2: world\n  example.property.file: |-\n    property.1=value-1\n    property.2=value-2\n    property.3=value-3`,\n    },\n  ],\n\n  'batch/v1.CronJob': [\n    {\n      title: 'Basic CronJob',\n      description: 'A basic CronJob example that runs daily',\n      yaml: `apiVersion: batch/v1\nkind: CronJob\nmetadata:\n  name: example\nspec:\n  schedule: \"@daily\"\n  jobTemplate:\n    spec:\n      template:\n        spec:\n          containers:\n          - name: hello\n            image: busybox\n            args:\n            - /bin/sh\n            - -c\n            - date; echo Hello from the Kubernetes cluster\n          restartPolicy: OnFailure`,\n    },\n  ],\n\n  'v1.PersistentVolume': [\n    {\n      title: 'Basic PersistentVolume',\n      description: 'A basic PersistentVolume example with NFS storage',\n      yaml: `apiVersion: v1\nkind: PersistentVolume\nmetadata:\n  name: example\nspec:\n  capacity:\n    storage: 5Gi\n  accessModes:\n    - ReadWriteOnce\n  persistentVolumeReclaimPolicy: Retain\n  storageClassName: slow\n  nfs:\n    path: /tmp\n    server: 172.17.0.2`,\n    },\n  ],\n\n  'autoscaling/v2.HorizontalPodAutoscaler': [\n    {\n      title: 'Basic HorizontalPodAutoscaler',\n      description: 'A basic HPA example with CPU utilization target',\n      yaml: `apiVersion: autoscaling/v2\nkind: HorizontalPodAutoscaler\nmetadata:\n  name: example\nspec:\n  scaleTargetRef:\n    apiVersion: apps/v1\n    kind: Deployment\n    name: example\n  minReplicas: 1\n  maxReplicas: 3\n  metrics:\n  - type: Resource\n    resource:\n      name: cpu\n      target:\n        averageUtilization: 50\n        type: Utilization`,\n    },\n  ],\n\n  'apps/v1.DaemonSet': [\n    {\n      title: 'Basic DaemonSet',\n      description: 'A basic DaemonSet example with nginx container',\n      yaml: `apiVersion: apps/v1\nkind: DaemonSet\nmetadata:\n  name: example\nspec:\n  selector:\n    matchLabels:\n      app: httpd\n  template:\n    metadata:\n      labels:\n        app: httpd\n    spec:\n      containers:\n      - name: httpd\n        image: internal-docker-registry.cpaas-system.svc/demo-ns/nginx:alpine\n        ports:\n        - containerPort: 8080`,\n    },\n  ],\n\n  'v1.PersistentVolumeClaim': [\n    {\n      title: 'Basic PersistentVolumeClaim',\n      description: 'A basic PVC example requesting 1Gi storage',\n      yaml: `apiVersion: v1\nkind: PersistentVolumeClaim\nmetadata:\n  name: example\nspec:\n  accessModes:\n    - ReadWriteOnce\n  volumeMode: Filesystem\n  resources:\n    requests:\n      storage: 1Gi`,\n    },\n  ],\n\n  'v1.ResourceQuota': [\n    {\n      title: 'Compute ResourceQuota',\n      description: 'A ResourceQuota example for compute resources',\n      yaml: `apiVersion: v1\nkind: ResourceQuota\nmetadata:\n  name: compute-quota\n  namespace: default\nspec:\n  hard:\n    requests.cpu: '1'\n    requests.memory: 1Gi\n    limits.cpu: '2'\n    limits.memory: 2Gi`,\n    },\n    {\n      title: 'Storage Class ResourceQuota',\n      description: 'A ResourceQuota example for storage class specific quotas',\n      yaml: `apiVersion: v1\nkind: ResourceQuota\nmetadata:\n  name: storage-class-quota\n  namespace: default\nspec:\n  hard:\n    requests.storage: 100Gi\n    persistentvolumeclaims: '100'\n    # For quota specific to a storage class, the storage class must have the same name\n    gold.storage-class.kubernetes.io/requests.storage: 3Gi\n    gold.storage-class.kubernetes.io/persistentvolumeclaims: '5'\n    silver.storage-class.kubernetes.io/requests.storage: 2Gi\n    silver.storage-class.kubernetes.io/persistentvolumeclaims: '3'\n    bronze.storage-class.kubernetes.io/requests.storage: 1Gi\n    bronze.storage-class.kubernetes.io/persistentvolumeclaims: '1'`,\n    },\n    {\n      title: 'Object Counts ResourceQuota',\n      description: 'A ResourceQuota example for object count limits',\n      yaml: `apiVersion: v1\nkind: ResourceQuota\nmetadata:\n  name: object-counts\n  namespace: default\nspec:\n  hard:\n    configmaps: \"10\"\n    persistentvolumeclaims: \"4\"\n    replicationcontrollers: \"20\"\n    secrets: \"10\"\n    services: \"10\"\n    services.loadbalancers: \"2\"`,\n    },\n  ],\n\n  'v1.LimitRange': [\n    {\n      title: 'Memory LimitRange',\n      description: 'A LimitRange example for container memory limits',\n      yaml: `apiVersion: v1\nkind: LimitRange\nmetadata:\n  name: mem-limit-range\nspec:\n  limits:\n  - default:\n      memory: 512Mi\n    defaultRequest:\n      memory: 256Mi\n    type: Container`,\n    },\n  ],\n\n  'apps/v1.StatefulSet': [\n    {\n      title: 'Basic StatefulSet',\n      description: 'A basic StatefulSet example with persistent storage',\n      yaml: `apiVersion: apps/v1\nkind: StatefulSet\nmetadata:\n  name: example\nspec:\n  serviceName: \"httpd\"\n  replicas: 3\n  selector:\n    matchLabels:\n      app: httpd\n  template:\n    metadata:\n      labels:\n        app: httpd\n    spec:\n      terminationGracePeriodSeconds: 10\n      containers:\n      - name: httpd\n        image: internal-docker-registry.cpaas-system.svc/demo-ns/nginx:alpine\n        ports:\n        - containerPort: 8080\n          name: web\n        volumeMounts:\n        - name: www\n          mountPath: /var/www/html\n  volumeClaimTemplates:\n  - metadata:\n      name: www\n    spec:\n      accessModes: [ \"ReadWriteOnce\" ]\n      storageClassName: my-storage-class\n      resources:\n        requests:\n          storage: 1Gi`,\n    },\n  ],\n\n  'storage.k8s.io/v1.StorageClass': [\n    {\n      title: 'Basic StorageClass',\n      description: 'A basic StorageClass example',\n      yaml: `apiVersion: storage.k8s.io/v1\nkind: StorageClass\nmetadata:\n  name: example\nprovisioner: my-provisioner\nreclaimPolicy: Delete`,\n    },\n  ],\n\n  'v1.Secret': [\n    {\n      title: 'Basic Secret',\n      description: 'A basic Secret example with username and password',\n      yaml: `apiVersion: v1\nkind: Secret\nmetadata:\n  name: example\ntype: Opaque\nstringData:\n  username: admin\n  password: opensesame`,\n    },\n  ],\n\n  'app.k8s.io/v1beta1.Application': [\n    {\n      title: 'Basic Application',\n      description: 'A basic Application example with Deployment and Service',\n      yaml: `apiVersion: apps/v1\nkind: Deployment\nmetadata:\n  labels:\n    app: nginx\n  name: nginx-deployment\n  namespace: yintest-ns1\nspec:\n  replicas: 1\n  selector:\n    matchLabels:\n      app: nginx\n  template:\n    metadata:\n      labels:\n        app: nginx\n    spec:\n      containers:\n        - image: nginx:1.7.9\n          name: nginx\n          ports:\n            - containerPort: 80\n---\napiVersion: v1\nkind: Service\nmetadata:\n  labels:\n    app: nginx\n  name: nginx\n  namespace: yintest-ns1\nspec:\n  ports:\n    - port: 80\n      protocol: TCP\n      targetPort: 80\n  selector:\n    app: nginx\n  type: ClusterIP`,\n    },\n  ],\n};"]}

package/esm2022/core/components/tree/node/component.mjs

@@ -30,7 +30,7 @@ export class NestedTreeNodeComponent extends CdkNestedTreeNode {
                     },
                 ], changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block}\n"] }]
     }], null, null); })();
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(NestedTreeNodeComponent, { className: "NestedTreeNodeComponent", filePath: "core/components/tree/node/component.ts", lineNumber: 35 }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(NestedTreeNodeComponent, { className: "NestedTreeNodeComponent" }); })();
 export class TreeNodeDefDirective extends CdkTreeNodeDef {
     static { this.ɵfac = /*@__PURE__*/ (() => { let ɵTreeNodeDefDirective_BaseFactory; return function TreeNodeDefDirective_Factory(t) { return (ɵTreeNodeDefDirective_BaseFactory || (ɵTreeNodeDefDirective_BaseFactory = i0.ɵɵgetInheritedFactory(TreeNodeDefDirective)))(t || TreeNodeDefDirective); }; })(); }
     static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: TreeNodeDefDirective, selectors: [["", "aclTreeNodeDef", ""]], inputs: { when: [0, "aclTreeNodeDefWhen", "when"] }, features: [i0.ɵɵProvidersFeature([{ provide: CdkTreeNodeDef, useExisting: TreeNodeDefDirective }]), i0.ɵɵInheritDefinitionFeature] }); }

package/esm2022/core/components/tree/tree/component.mjs

@@ -24,5 +24,5 @@ export class TreeComponent extends CdkTree {
             type: ViewChild,
             args: [TreeNodeOutletDirective, { static: true }]
         }] }); })();
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(TreeComponent, { className: "TreeComponent", filePath: "core/components/tree/tree/component.ts", lineNumber: 20 }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(TreeComponent, { className: "TreeComponent" }); })();
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2NvcmUvY29tcG9uZW50cy90cmVlL3RyZWUvY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2NvcmUvY29tcG9uZW50cy90cmVlL3RyZWUvdGVtcGxhdGUuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSw4RUFBOEU7QUFDOUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQzVDLE9BQU8sRUFDTCx1QkFBdUIsRUFDdkIsU0FBUyxFQUNULFNBQVMsRUFDVCxpQkFBaUIsR0FDbEIsTUFBTSxlQUFlLENBQUM7QUFFdkIsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sV0FBVyxDQUFDOzs7QUFVcEQsTUFBTSxPQUFPLGFBQW9CLFNBQVEsT0FBYTt3TkFBekMsYUFBYSxTQUFiLGFBQWE7b0VBQWIsYUFBYTsyQkFDYix1QkFBdUI7Ozs7cUVBSHZCLENBQUMsRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLFdBQVcsRUFBRSxhQUFhLEVBQUUsQ0FBQztZQ2pCL0QsOEJBQXVCO1lBQ3JCLDJCQUErQztZQUNqRCxpQkFBTTs7O2lGRGlCTyxhQUFhO2NBUnpCLFNBQVM7MkJBQ0UsVUFBVSxZQUNWLFNBQVMsaUJBRUosaUJBQWlCLENBQUMsSUFBSSxtQkFDcEIsdUJBQXVCLENBQUMsT0FBTyxhQUNyQyxDQUFDLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxXQUFXLGVBQWUsRUFBRSxDQUFDO2dCQUlwRCxXQUFXO2tCQURuQixTQUFTO21CQUFDLHVCQUF1QixFQUFFLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRTs7a0ZBRHpDLGFBQWEiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBAYW5ndWxhci1lc2xpbnQvcHJlZmVyLW9uLXB1c2gtY29tcG9uZW50LWNoYW5nZS1kZXRlY3Rpb24gKi9cbmltcG9ydCB7IENka1RyZWUgfSBmcm9tICdAYW5ndWxhci9jZGsvdHJlZSc7XG5pbXBvcnQge1xuICBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSxcbiAgQ29tcG9uZW50LFxuICBWaWV3Q2hpbGQsXG4gIFZpZXdFbmNhcHN1bGF0aW9uLFxufSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgVHJlZU5vZGVPdXRsZXREaXJlY3RpdmUgfSBmcm9tICcuLi9vdXRsZXQnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdhY2wtdHJlZScsXG4gIGV4cG9ydEFzOiAnYWNsVHJlZScsXG4gIHRlbXBsYXRlVXJsOiAndGVtcGxhdGUuaHRtbCcsXG4gIGVuY2Fwc3VsYXRpb246IFZpZXdFbmNhcHN1bGF0aW9uLk5vbmUsXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuRGVmYXVsdCxcbiAgcHJvdmlkZXJzOiBbeyBwcm92aWRlOiBDZGtUcmVlLCB1c2VFeGlzdGluZzogVHJlZUNvbXBvbmVudCB9XSxcbn0pXG5leHBvcnQgY2xhc3MgVHJlZUNvbXBvbmVudDxULCBLPiBleHRlbmRzIENka1RyZWU8VCwgSz4ge1xuICBAVmlld0NoaWxkKFRyZWVOb2RlT3V0bGV0RGlyZWN0aXZlLCB7IHN0YXRpYzogdHJ1ZSB9KVxuICBvdmVycmlkZSBfbm9kZU91dGxldDogVHJlZU5vZGVPdXRsZXREaXJlY3RpdmU7XG59XG4iLCI8ZGl2IGNsYXNzPVwidHJlZS1saXN0XCI+XG4gIDxuZy1jb250YWluZXIgYWNsVHJlZU5vZGVPdXRsZXQ+PC9uZy1jb250YWluZXI+XG48L2Rpdj5cbiJdfQ==

package/esm2022/core/directives/readonly-field.directive.mjs

@@ -154,5 +154,5 @@ export class SpanComponent {
         type: Component,
         args: [{ template: `<span>{{ data | aclFieldNotAvailable }}</span>`, changeDetection: ChangeDetectionStrategy.Default, styles: ["span{word-break:break-all}\n"] }]
     }], null, null); })();
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(SpanComponent, { className: "SpanComponent", filePath: "core/directives/readonly-field.directive.ts", lineNumber: 204 }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(SpanComponent, { className: "SpanComponent" }); })();
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"readonly-field.directive.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/directives/readonly-field.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module utils\n */\n\nimport { FormItemControlDirective } from '@alauda/ui';\nimport {\n  CdkPortalOutlet,\n  ComponentPortal,\n  TemplatePortal,\n} from '@angular/cdk/portal';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  ComponentFactoryResolver,\n  ComponentRef,\n  Directive,\n  HostBinding,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Self,\n  TemplateRef,\n  ViewContainerRef,\n} from '@angular/core';\nimport {\n  AbstractControl,\n  AsyncValidatorFn,\n  NgControl,\n  ValidatorFn,\n} from '@angular/forms';\nimport {\n  Observable,\n  Subject,\n  combineLatest,\n  distinctUntilChanged,\n  filter,\n  map,\n  startWith,\n  takeUntil,\n} from 'rxjs';\n\nimport { ObservableInput } from '../utils/decorators';\n\n@Directive({\n  selector: '[aclReadonlyField]',\n  standalone: true,\n})\nexport class ReadonlyFieldDirective implements OnInit, OnDestroy {\n  @Input()\n  aclReadonlyField: boolean;\n\n  @ObservableInput()\n  aclReadonlyField$: Observable<boolean>;\n\n  @Input()\n  hidden: boolean;\n\n  private isControlRequired = false;\n\n  private spanComponentRef: ComponentRef<SpanComponent>;\n\n  private readonly templateContext = {};\n\n  private readonly destroy$ = new Subject<void>();\n\n  // 自定义模板\n  @Input('aclReadonlyFieldTemplate')\n  template: TemplateRef<any>;\n\n  // 自定义模板\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('aclReadonlyFieldTemplateContext')\n  context: object;\n\n  @HostBinding('hidden')\n  get isHidden() {\n    return this.hidden || this.aclReadonlyField;\n  }\n\n  constructor(\n    private readonly control: NgControl,\n    // eslint-disable-next-line sonar/deprecation\n    private readonly cfr: ComponentFactoryResolver,\n    private readonly viewContainerRef: ViewContainerRef,\n    // 仅考虑当前control，子control无法知晓父FormItemControl元素 ，包裹了多少个control，以及各自处于什么状态，该情况自行处理\n    @Self()\n    @Optional()\n    private readonly controlDirective: FormItemControlDirective,\n  ) {}\n\n  private setValue(value: unknown) {\n    if (this.template) {\n      Object.assign(this.templateContext, {\n        $implicit: value,\n        ...this.context,\n      });\n    } else {\n      this.spanComponentRef.instance.setData(value);\n    }\n  }\n\n  ngOnInit() {\n    const controlEntity = this.control.control;\n    // formControl will compose multi validators to 1, no matter defined in template nor FormBuilder\n    const { validator, asyncValidator } = controlEntity;\n    this.isControlRequired = this.controlDirective?.required || false;\n    const portalOutlet = new CdkPortalOutlet(this.cfr, this.viewContainerRef);\n    const portal = this.template\n      ? new TemplatePortal(\n          this.template,\n          this.viewContainerRef,\n          this.templateContext,\n        )\n      : new ComponentPortal(SpanComponent, this.viewContainerRef);\n\n    const containerAttached$ = this.aclReadonlyField$.pipe(\n      distinctUntilChanged(),\n      map(isUpdate => {\n        if (!isUpdate) {\n          // 重置\n          if (this.controlDirective) {\n            this.controlDirective.required = this.isControlRequired;\n          }\n          if (portalOutlet.hasAttached()) {\n            portalOutlet.detach();\n          }\n          this.applyValidators(controlEntity, validator, asyncValidator);\n          return false;\n        }\n\n        if (this.controlDirective) {\n          this.controlDirective.required = false;\n        }\n        const attachPoint = portalOutlet.attach(portal);\n        if (!this.template) {\n          this.spanComponentRef = attachPoint as ComponentRef<SpanComponent>;\n        }\n        this.clearValidators(controlEntity);\n        return true;\n      }),\n    );\n\n    const sourceValue$ = this.control.valueChanges.pipe(\n      startWith(this.control.value),\n    );\n\n    combineLatest([sourceValue$, containerAttached$])\n      .pipe(\n        takeUntil(this.destroy$),\n        filter(([, attached]) => !!attached),\n      )\n      .subscribe(([value]) => {\n        this.setValue(value);\n      });\n  }\n\n  private applyValidators(\n    control: AbstractControl,\n    rawValidator?: ValidatorFn,\n    rawAsyncValidator?: AsyncValidatorFn,\n  ) {\n    if (\n      control.validator === rawValidator &&\n      control.asyncValidator === rawAsyncValidator\n    ) {\n      return;\n    }\n    control.setValidators(rawValidator);\n    control.setAsyncValidators(rawAsyncValidator);\n    control.updateValueAndValidity();\n  }\n\n  private clearValidators(control: AbstractControl) {\n    // delay checking validators for ngModel\n    requestAnimationFrame(() => {\n      if (!control.validator && !control.asyncValidator) {\n        return;\n      }\n      control.clearValidators();\n      control.clearAsyncValidators();\n      control.updateValueAndValidity();\n    });\n  }\n\n  ngOnDestroy() {\n    this.destroy$.next();\n  }\n}\n\n@Component({\n  template: `<span>{{ data | aclFieldNotAvailable }}</span>`,\n  styles: [\n    `\n      span {\n        word-break: break-all;\n      }\n    `,\n  ],\n  // eslint-disable-next-line @angular-eslint/prefer-on-push-component-change-detection\n  changeDetection: ChangeDetectionStrategy.Default,\n})\nexport class SpanComponent<T = unknown> {\n  data: T;\n\n  setData(value: T) {\n    this.data = value;\n  }\n}\n"]}

package/esm2022/core/services/kubernetes-schema.service.mjs

@@ -5,28 +5,31 @@ import { API_GATEWAY } from '../constants/constants';
 import { WorkspaceHelperService } from './workspace-helper.service';
 import * as i0 from "@angular/core";
 export class KubernetesSchemaService {
-    get definitions() {
-        return this.schemaCache?.get(this.workspaceHelper?.baseParamsSnapshot.cluster)?.definitions;
-    }
     constructor() {
         this.http = inject(HttpClient);
-        // 使用可选依赖注入
-        this.workspaceHelper = inject(WorkspaceHelperService, {
-            optional: true,
-        });
+        // 移除可选依赖注入，改为直接注入
+        this.workspaceHelper = inject(WorkspaceHelperService);
+        this.initialized = false;
         this.schemaCache = new Map();
         this.schemaCache$$ = new BehaviorSubject(new Map());
-        // 只有当 WorkspaceHelperService 可用时才监听集群变化
-        if (this.workspaceHelper) {
+    }
+    get definitions() {
+        return this.schemaCache?.get(this.workspaceHelper?.baseParamsSnapshot.cluster)?.definitions;
+    }
+    // 延迟初始化方法
+    ensureInitialized() {
+        if (!this.initialized && this.workspaceHelper) {
             this.workspaceHelper.baseParams.subscribe(() => {
                 this.clearCache();
             });
+            this.initialized = true;
         }
     }
     /**
      * 获取当前集群的 OpenAPI schema
      */
     getOpenAPISchema() {
+        this.ensureInitialized();
         // 如果没有 WorkspaceHelperService，返回 null
         if (!this.workspaceHelper) {
             console.warn('WorkspaceHelperService not available, cannot fetch OpenAPI schema');
@@ -117,9 +120,10 @@ export class KubernetesSchemaService {
         }));
     }
     static { this.ɵfac = function KubernetesSchemaService_Factory(t) { return new (t || KubernetesSchemaService)(); }; }
-    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: KubernetesSchemaService, factory: KubernetesSchemaService.ɵfac }); }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: KubernetesSchemaService, factory: KubernetesSchemaService.ɵfac, providedIn: 'root' }); }
 }
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(KubernetesSchemaService, [{
-        type: Injectable
-    }], () => [], null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kubernetes-schema.service.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/services/kubernetes-schema.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Injectable, inject } from '@angular/core';\nimport {\n  Observable,\n  BehaviorSubject,\n  switchMap,\n  shareReplay,\n  catchError,\n  of,\n  tap,\n  debounceTime,\n} from 'rxjs';\n\nimport { API_GATEWAY } from '../constants/constants';\nimport { OpenAPIV2Document } from '../types/openapi';\nimport { OpenAPIV3SchemaObject } from '../types/schema';\n\nimport { WorkspaceHelperService } from './workspace-helper.service';\n\n@Injectable()\nexport class KubernetesSchemaService {\n  private readonly http = inject(HttpClient);\n  // 使用可选依赖注入\n  readonly workspaceHelper = inject(WorkspaceHelperService, {\n    optional: true,\n  });\n\n  private readonly schemaCache = new Map<string, OpenAPIV2Document>();\n  private readonly schemaCache$$ = new BehaviorSubject<\n    Map<string, OpenAPIV2Document>\n  >(new Map());\n\n  get definitions() {\n    return this.schemaCache?.get(\n      this.workspaceHelper?.baseParamsSnapshot.cluster,\n    )?.definitions;\n  }\n\n  constructor() {\n    // 只有当 WorkspaceHelperService 可用时才监听集群变化\n    if (this.workspaceHelper) {\n      this.workspaceHelper.baseParams.subscribe(() => {\n        this.clearCache();\n      });\n    }\n  }\n\n  /**\n   * 获取当前集群的 OpenAPI schema\n   */\n  getOpenAPISchema(): Observable<OpenAPIV2Document | null> {\n    // 如果没有 WorkspaceHelperService，返回 null\n    if (!this.workspaceHelper) {\n      console.warn(\n        'WorkspaceHelperService not available, cannot fetch OpenAPI schema',\n      );\n      return of(null);\n    }\n\n    return this.workspaceHelper.baseParams.pipe(\n      switchMap(workspace => {\n        const cluster = workspace.cluster || 'global';\n        const cached = this.schemaCache.get(cluster);\n\n        if (cached) {\n          return of(cached);\n        }\n\n        return this.fetchOpenAPISchema(cluster).pipe(\n          tap(schema => {\n            if (schema) {\n              this.schemaCache.set(cluster, schema);\n              this.schemaCache$$.next(new Map(this.schemaCache));\n            }\n          }),\n          catchError(error => {\n            console.error(\n              `Failed to fetch OpenAPI schema for cluster ${cluster}:`,\n              error,\n            );\n            return of(null);\n          }),\n        );\n      }),\n      shareReplay(1),\n    );\n  }\n\n  /**\n   * 根据 Kubernetes 资源类型获取对应的 schema\n   */\n  getResourceSchema(\n    apiVersion: string,\n    kind: string,\n  ): Observable<OpenAPIV3SchemaObject | null> {\n    return this.getOpenAPISchema().pipe(\n      switchMap(openApiDoc => {\n        if (!openApiDoc?.definitions) {\n          return of(null);\n        }\n\n        // 尝试多种可能的 schema key 格式\n        const possibleKeys = [\n          `${apiVersion}.${kind}`,\n          `${apiVersion}/${kind}`,\n          kind,\n          `io.k8s.api.${apiVersion.replace('/', '.')}.${kind}`,\n          `io.k8s.api.${apiVersion.split('/')[0]}.${apiVersion.split('/')[1] || 'v1'}.${kind}`,\n        ];\n\n        for (const key of possibleKeys) {\n          const schema = openApiDoc.definitions[key];\n          if (schema) {\n            return of(schema);\n          }\n        }\n\n        // 如果没有找到精确匹配，尝试模糊匹配\n        const fuzzyKey = Object.keys(openApiDoc.definitions).find(key =>\n          key.toLowerCase().includes(kind.toLowerCase()),\n        );\n\n        if (fuzzyKey) {\n          return of(openApiDoc.definitions[fuzzyKey]);\n        }\n\n        return of(null);\n      }),\n    );\n  }\n\n  /**\n   * 获取所有可用的资源定义\n   */\n  getAllResourceDefinitions(): Observable<Record<\n    string,\n    OpenAPIV3SchemaObject\n  > | null> {\n    return this.getOpenAPISchema().pipe(\n      switchMap(openApiDoc => {\n        return of(openApiDoc?.definitions || null);\n      }),\n    );\n  }\n\n  /**\n   * 清理缓存\n   */\n  clearCache(): void {\n    this.schemaCache.clear();\n    this.schemaCache$$.next(new Map());\n  }\n\n  /**\n   * 获取缓存状态\n   */\n  getCacheStatus(): Observable<Map<string, OpenAPIV2Document>> {\n    return this.schemaCache$$.asObservable();\n  }\n\n  /**\n   * 检查 WorkspaceHelperService 是否可用\n   */\n  isWorkspaceHelperAvailable(): boolean {\n    return !!this.workspaceHelper;\n  }\n\n  /**\n   * 从 Kubernetes API 获取 OpenAPI schema\n   */\n  private fetchOpenAPISchema(cluster: string): Observable<OpenAPIV2Document> {\n    const url = `${API_GATEWAY}/kubernetes/${cluster}/openapi/v2`;\n\n    return this.http.get<OpenAPIV2Document>(url).pipe(\n      debounceTime(500),\n      catchError(error => {\n        console.error(\n          `Failed to fetch OpenAPI schema for cluster ${cluster}:`,\n          error,\n        );\n        return of(null);\n      }),\n    );\n  }\n}\n"]}
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kubernetes-schema.service.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/services/kubernetes-schema.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Injectable, inject } from '@angular/core';\nimport {\n  Observable,\n  BehaviorSubject,\n  switchMap,\n  shareReplay,\n  catchError,\n  of,\n  tap,\n  debounceTime,\n} from 'rxjs';\n\nimport { API_GATEWAY } from '../constants/constants';\nimport { OpenAPIV2Document } from '../types/openapi';\nimport { OpenAPIV3SchemaObject } from '../types/schema';\n\nimport { WorkspaceHelperService } from './workspace-helper.service';\n\n@Injectable({ providedIn: 'root' })\nexport class KubernetesSchemaService {\n  private readonly http = inject(HttpClient);\n  // 移除可选依赖注入，改为直接注入\n  readonly workspaceHelper = inject(WorkspaceHelperService);\n\n  private initialized = false;\n  private readonly schemaCache = new Map<string, OpenAPIV2Document>();\n  private readonly schemaCache$$ = new BehaviorSubject<\n    Map<string, OpenAPIV2Document>\n  >(new Map());\n\n  get definitions() {\n    return this.schemaCache?.get(\n      this.workspaceHelper?.baseParamsSnapshot.cluster,\n    )?.definitions;\n  }\n\n  // 延迟初始化方法\n  private ensureInitialized() {\n    if (!this.initialized && this.workspaceHelper) {\n      this.workspaceHelper.baseParams.subscribe(() => {\n        this.clearCache();\n      });\n      this.initialized = true;\n    }\n  }\n\n  /**\n   * 获取当前集群的 OpenAPI schema\n   */\n  getOpenAPISchema(): Observable<OpenAPIV2Document | null> {\n    this.ensureInitialized();\n\n    // 如果没有 WorkspaceHelperService，返回 null\n    if (!this.workspaceHelper) {\n      console.warn(\n        'WorkspaceHelperService not available, cannot fetch OpenAPI schema',\n      );\n      return of(null);\n    }\n\n    return this.workspaceHelper.baseParams.pipe(\n      switchMap(workspace => {\n        const cluster = workspace.cluster || 'global';\n        const cached = this.schemaCache.get(cluster);\n\n        if (cached) {\n          return of(cached);\n        }\n\n        return this.fetchOpenAPISchema(cluster).pipe(\n          tap(schema => {\n            if (schema) {\n              this.schemaCache.set(cluster, schema);\n              this.schemaCache$$.next(new Map(this.schemaCache));\n            }\n          }),\n          catchError(error => {\n            console.error(\n              `Failed to fetch OpenAPI schema for cluster ${cluster}:`,\n              error,\n            );\n            return of(null);\n          }),\n        );\n      }),\n      shareReplay(1),\n    );\n  }\n\n  /**\n   * 根据 Kubernetes 资源类型获取对应的 schema\n   */\n  getResourceSchema(\n    apiVersion: string,\n    kind: string,\n  ): Observable<OpenAPIV3SchemaObject | null> {\n    return this.getOpenAPISchema().pipe(\n      switchMap(openApiDoc => {\n        if (!openApiDoc?.definitions) {\n          return of(null);\n        }\n\n        // 尝试多种可能的 schema key 格式\n        const possibleKeys = [\n          `${apiVersion}.${kind}`,\n          `${apiVersion}/${kind}`,\n          kind,\n          `io.k8s.api.${apiVersion.replace('/', '.')}.${kind}`,\n          `io.k8s.api.${apiVersion.split('/')[0]}.${apiVersion.split('/')[1] || 'v1'}.${kind}`,\n        ];\n\n        for (const key of possibleKeys) {\n          const schema = openApiDoc.definitions[key];\n          if (schema) {\n            return of(schema);\n          }\n        }\n\n        // 如果没有找到精确匹配，尝试模糊匹配\n        const fuzzyKey = Object.keys(openApiDoc.definitions).find(key =>\n          key.toLowerCase().includes(kind.toLowerCase()),\n        );\n\n        if (fuzzyKey) {\n          return of(openApiDoc.definitions[fuzzyKey]);\n        }\n\n        return of(null);\n      }),\n    );\n  }\n\n  /**\n   * 获取所有可用的资源定义\n   */\n  getAllResourceDefinitions(): Observable<Record<\n    string,\n    OpenAPIV3SchemaObject\n  > | null> {\n    return this.getOpenAPISchema().pipe(\n      switchMap(openApiDoc => {\n        return of(openApiDoc?.definitions || null);\n      }),\n    );\n  }\n\n  /**\n   * 清理缓存\n   */\n  clearCache(): void {\n    this.schemaCache.clear();\n    this.schemaCache$$.next(new Map());\n  }\n\n  /**\n   * 获取缓存状态\n   */\n  getCacheStatus(): Observable<Map<string, OpenAPIV2Document>> {\n    return this.schemaCache$$.asObservable();\n  }\n\n  /**\n   * 检查 WorkspaceHelperService 是否可用\n   */\n  isWorkspaceHelperAvailable(): boolean {\n    return !!this.workspaceHelper;\n  }\n\n  /**\n   * 从 Kubernetes API 获取 OpenAPI schema\n   */\n  private fetchOpenAPISchema(cluster: string): Observable<OpenAPIV2Document> {\n    const url = `${API_GATEWAY}/kubernetes/${cluster}/openapi/v2`;\n\n    return this.http.get<OpenAPIV2Document>(url).pipe(\n      debounceTime(500),\n      catchError(error => {\n        console.error(\n          `Failed to fetch OpenAPI schema for cluster ${cluster}:`,\n          error,\n        );\n        return of(null);\n      }),\n    );\n  }\n}\n"]}

package/esm2022/core/services/workspace-helper.service.mjs

@@ -19,9 +19,10 @@ export class WorkspaceHelperService {
         this._baseActivatedRoute = route;
     }
     static { this.ɵfac = function WorkspaceHelperService_Factory(t) { return new (t || WorkspaceHelperService)(); }; }
-    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WorkspaceHelperService, factory: WorkspaceHelperService.ɵfac }); }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: WorkspaceHelperService, factory: WorkspaceHelperService.ɵfac, providedIn: 'root' }); }
 }
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WorkspaceHelperService, [{
-        type: Injectable
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
     }], null, null); })();
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya3NwYWNlLWhlbHBlci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2NvcmUvc2VydmljZXMvd29ya3NwYWNlLWhlbHBlci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFM0MsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBSy9DLE1BQU0sT0FBTyxzQkFBc0I7SUFEbkM7UUFFbUIsaUJBQVksR0FBRyxJQUFJLGVBQWUsQ0FBWSxJQUFJLENBQUMsQ0FBQztRQUc1RCxlQUFVLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxZQUFZLEVBQUUsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7S0FpQjlFO0lBZkMsSUFBSSxrQkFBa0I7UUFDcEIsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssQ0FBQztJQUNqQyxDQUFDO0lBRUQsSUFBSSxrQkFBa0I7UUFDcEIsT0FBTyxJQUFJLENBQUMsbUJBQW1CLENBQUM7SUFDbEMsQ0FBQztJQUVELGFBQWEsQ0FBQyxNQUFpQjtRQUM3QixJQUFJLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBRUQscUJBQXFCLENBQUMsS0FBcUI7UUFDekMsSUFBSSxDQUFDLG1CQUFtQixHQUFHLEtBQUssQ0FBQztJQUNuQyxDQUFDO3VGQXBCVSxzQkFBc0I7dUVBQXRCLHNCQUFzQixXQUF0QixzQkFBc0I7O2lGQUF0QixzQkFBc0I7Y0FEbEMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFjdGl2YXRlZFJvdXRlIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcbmltcG9ydCB7IEJlaGF2aW9yU3ViamVjdCwgZmlsdGVyIH0gZnJvbSAncnhqcyc7XG5cbmltcG9ydCB7IFdvcmtzcGFjZSB9IGZyb20gJy4uL3V0aWxzL3dvcmtzcGFjZSc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBXb3Jrc3BhY2VIZWxwZXJTZXJ2aWNlIHtcbiAgcHJpdmF0ZSByZWFkb25seSBiYXNlUGFyYW1zJCQgPSBuZXcgQmVoYXZpb3JTdWJqZWN0PFdvcmtzcGFjZT4obnVsbCk7XG4gIHByaXZhdGUgX2Jhc2VBY3RpdmF0ZWRSb3V0ZTogQWN0aXZhdGVkUm91dGU7XG5cbiAgcmVhZG9ubHkgYmFzZVBhcmFtcyA9IHRoaXMuYmFzZVBhcmFtcyQkLmFzT2JzZXJ2YWJsZSgpLnBpcGUoZmlsdGVyKEJvb2xlYW4pKTtcblxuICBnZXQgYmFzZVBhcmFtc1NuYXBzaG90KCkge1xuICAgIHJldHVybiB0aGlzLmJhc2VQYXJhbXMkJC52YWx1ZTtcbiAgfVxuXG4gIGdldCBiYXNlQWN0aXZhdGVkUm91dGUoKSB7XG4gICAgcmV0dXJuIHRoaXMuX2Jhc2VBY3RpdmF0ZWRSb3V0ZTtcbiAgfVxuXG4gIHNldEJhc2VQYXJhbXMocGFyYW1zOiBXb3Jrc3BhY2UpIHtcbiAgICB0aGlzLmJhc2VQYXJhbXMkJC5uZXh0KHBhcmFtcyk7XG4gIH1cblxuICBzZXRCYXNlQWN0aXZhdGVkUm91dGUocm91dGU6IEFjdGl2YXRlZFJvdXRlKSB7XG4gICAgdGhpcy5fYmFzZUFjdGl2YXRlZFJvdXRlID0gcm91dGU7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/custom-columns-setting/component.mjs

@@ -110,5 +110,5 @@ export class TableCustomColumnsComponent {
         }], columnsChange: [{
             type: Output
         }] }); })();
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(TableCustomColumnsComponent, { className: "TableCustomColumnsComponent", filePath: "custom-columns-setting/component.ts", lineNumber: 40 }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(TableCustomColumnsComponent, { className: "TableCustomColumnsComponent" }); })();
 //# sourceMappingURL=data:application/json;base64,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

package/esm2022/disabled-container/disabled-container.component.mjs

@@ -87,5 +87,5 @@ __decorate([
         }], isDisabled: [{
             type: Input
         }], isAllowed$: [], isDisabled$: [], tooltip$: [] }); })();
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(DisabledContainerComponent, { className: "DisabledContainerComponent", filePath: "disabled-container/disabled-container.component.ts", lineNumber: 31 }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(DisabledContainerComponent, { className: "DisabledContainerComponent" }); })();
 //# sourceMappingURL=data:application/json;base64,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

package/esm2022/editable/editable.component.mjs

@@ -120,5 +120,5 @@ export class EditableComponent {
             type: ContentChild,
             args: [EditableEditorDirective, { read: TemplateRef }]
         }] }); })();
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(EditableComponent, { className: "EditableComponent", filePath: "editable/editable.component.ts", lineNumber: 38 }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(EditableComponent, { className: "EditableComponent" }); })();
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editable.component.js","sourceRoot":"","sources":["../../../../../libs/common/src/editable/editable.component.ts","../../../../../libs/common/src/editable/editable.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  buildBem,\n  ButtonModule,\n  CustomBeforeAction,\n  IconComponent,\n} from '@alauda/ui';\nimport { NgIf, NgTemplateOutlet } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  ContentChild,\n  EventEmitter,\n  Output,\n  TemplateRef,\n  computed,\n  effect,\n  input,\n  signal,\n} from '@angular/core';\nimport { finalize, first, from } from 'rxjs';\n\nimport {\n  EditableEditorDirective,\n  EditableViewerDirective,\n} from './editable.directive';\nimport { ButtonPosition, EditableMode } from './editable.type';\n\nconst bem = buildBem('acl-editable');\n\n@Component({\n  selector: 'acl-editable',\n  templateUrl: 'editable.component.html',\n  styleUrls: ['editable.component.scss'],\n  standalone: true,\n  imports: [NgIf, NgTemplateOutlet, IconComponent, ButtonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class EditableComponent {\n  beforeSave = input<CustomBeforeAction<unknown>>();\n\n  position = input<ButtonPosition>('top');\n\n  @Output() save: EventEmitter<void> = new EventEmitter<void>();\n  @Output() cancel: EventEmitter<void> = new EventEmitter<void>();\n  @Output() modeChange: EventEmitter<EditableMode> =\n    new EventEmitter<EditableMode>();\n\n  @ContentChild(EditableViewerDirective, { read: TemplateRef })\n  viewer: TemplateRef<unknown>;\n\n  @ContentChild(EditableEditorDirective, { read: TemplateRef })\n  editor: TemplateRef<unknown>;\n\n  EditableMode = EditableMode;\n  bem = bem;\n  loading = false;\n\n  mode = signal(EditableMode.View);\n\n  hostClass = computed(() => {\n    return `${bem.block()} ${bem.modifier(this.position())}`;\n  });\n\n  constructor() {\n    effect(() => {\n      this.modeChange.emit(this.mode());\n    });\n  }\n\n  saveEdit() {\n    this.loading = true;\n    from(this.beforeSave()?.() || Promise.resolve())\n      .pipe(\n        first(),\n        finalize(() => (this.loading = false)),\n      )\n      .subscribe(isContinue => {\n        if (isContinue === false) {\n          return;\n        }\n        this.mode.set(EditableMode.View);\n        this.save.emit();\n      });\n  }\n\n  cancelEdit() {\n    this.mode.set(EditableMode.View);\n    this.cancel.emit();\n  }\n}\n","<div [class]=\"hostClass()\">\n  <div\n    [class]=\"bem.element('viewer-container')\"\n    *ngIf=\"mode() === EditableMode.View\"\n  >\n    <ng-container [ngTemplateOutlet]=\"viewer\"> </ng-container>\n    <button\n      aui-button=\"text\"\n      [square]=\"true\"\n      (click)=\"mode.set(EditableMode.Edit)\"\n    >\n      <aui-icon icon=\"pencil\"></aui-icon>\n    </button>\n  </div>\n  <ng-container *ngIf=\"mode() === EditableMode.Edit\">\n    <div [class]=\"bem.element('editor-container')\">\n      <ng-container [ngTemplateOutlet]=\"editor\"> </ng-container>\n      <button\n        aui-button=\"text\"\n        [square]=\"true\"\n        [disabled]=\"loading\"\n        (click)=\"saveEdit()\"\n      >\n        <aui-icon [icon]=\"loading ? 'spinner' : 'check'\"></aui-icon>\n      </button>\n      <button\n        aui-button=\"text\"\n        [square]=\"true\"\n        (click)=\"cancelEdit()\"\n      >\n        <aui-icon icon=\"xmark\"></aui-icon>\n      </button>\n    </div>\n  </ng-container>\n</div>\n"]}