@kubed.io/cdn 0.0.1 → 0.0.4

package/dist/k8s/events.d.ts

@@ -0,0 +1,63 @@
+import type { TableData } from '../kd/elements/table';
+/** The labels the kube-events source puts on each line. */
+export interface EventLabels {
+    kind?: string;
+    name?: string;
+    namespace?: string;
+    objectAPIversion?: string;
+    reason?: string;
+    type?: string;
+    sourcecomponent?: string;
+    reportingcontroller?: string;
+    [key: string]: unknown;
+}
+/** One Loki log row, as Business Text hands a frame's rows to a panel. */
+export interface EventRow {
+    labels?: EventLabels | string;
+    Line?: string;
+    body?: string;
+    Time?: number | string;
+    timestamp?: number | string;
+    tsNs?: string;
+    [key: string]: unknown;
+}
+/** One folded event. */
+export interface EventGroup {
+    kind: string;
+    name: string;
+    namespace: string;
+    apiVersion: string;
+    reason: string;
+    message: string;
+    /** The component that reported it. */
+    source: string;
+    warning: boolean;
+    count: number;
+    /** ms */
+    first: number;
+    /** ms */
+    last: number;
+}
+/** Reasons that mean something went wrong, for sources whose lines carry no `type` label. */
+export declare const WARNING_REASONS: RegExp;
+/** Whether an event is a warning: its `type` label says so, or its reason does. */
+export declare function isWarning(labels: EventLabels): boolean;
+/**
+ * The log rows in whatever Business Text or a query hands over: rows, an
+ * array of frames' rows, or data frames with `fields`. Rows that are not log
+ * lines (an Infinity query's rows in the same panel) are dropped.
+ */
+export declare function eventRows(input: unknown): EventRow[];
+/** Events folded by object, reason and message, the most recent first. */
+export declare function foldEvents(input: unknown): EventGroup[];
+/** Which optional columns an events table has. */
+export interface EventColumns {
+    /** The object each event is about, for a view of many objects (a namespace, a workload). */
+    object?: boolean;
+    /** The object's namespace, for a cluster-wide view (a node). */
+    namespace?: boolean;
+    /** The end of the time range, in ms: "last seen" is measured to it. */
+    now?: number;
+}
+/** Folded events as `kd-table` data: reason pill, [namespace], [object], message, count, last seen. */
+export declare function eventsTable(groups: EventGroup[], opt?: EventColumns): TableData;

package/dist/k8s/icons.d.ts

@@ -0,0 +1,18 @@
+/** The Kubernetes wheel: a kind nobody drew an icon for. */
+export declare const DEFAULT_ICON = "https://cdn.jsdelivr.net/gh/cncf/artwork@002662490acb2303c7301acc0256c00790e03e9f/projects/kubernetes/icon/color/kubernetes-icon-color.svg";
+/** A custom resource whose group has no icon of its own. */
+export declare const CRD_ICON: string;
+/** The kubernetes/community icon of each built-in kind that has one. */
+export declare const KIND_ICONS: Readonly<Record<string, string>>;
+/** The icon of each API group that has one; a group missing here falls back to `CRD_ICON`. */
+export declare const GROUP_ICONS: Readonly<Record<string, string>>;
+/** The group of an apiVersion: `apps` for `apps/v1`, `''` for `v1`. */
+export declare function apiGroup(apiVersion: string | null | undefined): string;
+/** Whether a group is served by Kubernetes itself rather than a CRD or an aggregated API. */
+export declare function isBuiltInGroup(group: string): boolean;
+/**
+ * The icon of a kind. With an apiVersion, a custom resource takes its group's
+ * icon (or the CRD icon), so a `ServiceAccount` of some operator's group is not
+ * drawn as the core one. A kind with no icon at all gets `DEFAULT_ICON`.
+ */
+export declare function kindIcon(kind: string | null | undefined, apiVersion?: string | null): string;

package/dist/k8s/index.d.ts

@@ -0,0 +1,13 @@
+import '../kd/index';
+import './elements/events';
+import './elements/object';
+import './elements/ref';
+export { VERSION } from '../kd/define';
+export { applyTheme } from '../kd/theme';
+export { CRD_ICON, DEFAULT_ICON, GROUP_ICONS, KIND_ICONS, apiGroup, isBuiltInGroup, kindIcon } from './icons';
+export { DASHBOARDS, WORKLOAD_KINDS, apiPath, definitionRoute, kindLink, namespaceLink, namespaceRoute, plural, refLink, route, type LinkOptions, type ObjectRef, type RefCell, type Route, } from './links';
+export { HIDDEN_ANNOTATIONS, NEGATIVE_CONDITIONS, age, annotations, bar, chips, conditionOk, conditions, duration, labels, owners, quantity, resources, summary, trimmed, type Condition, type ContainerLike, type K8sObject, type MapOptions, type ObjectMeta, type OwnerReference, type ResourceMeter, type ResourceRequirements, } from './map';
+export { WARNING_REASONS, eventRows, eventsTable, foldEvents, isWarning, type EventColumns, type EventGroup, type EventLabels, type EventRow, } from './events';
+export { KdK8sEvents } from './elements/events';
+export { KdK8sObject } from './elements/object';
+export { KdK8sRef } from './elements/ref';

package/dist/k8s/links.d.ts

@@ -0,0 +1,72 @@
+import type { DashboardCell, HrefCell } from '../kd/cell';
+import type { Vars } from '../kd/elements/link';
+/** What names one Kubernetes object. */
+export interface ObjectRef {
+    kind: string;
+    name: string;
+    namespace?: string | null;
+    apiVersion?: string | null;
+    /** The resource name (`deployments`) when the kind's plural is irregular; guessed otherwise. */
+    plural?: string | null;
+}
+/** A dashboard and its variables. */
+export interface Route {
+    dashboard: string;
+    vars: Vars;
+}
+/** Options for a link cell. */
+export interface LinkOptions {
+    /** The label; defaults to the object's name. */
+    text?: string;
+    /** False leaves the icon out; a string replaces it. */
+    icon?: boolean | string;
+    /** Tooltip; defaults to the kind. */
+    title?: string;
+}
+/** A dashboard link, or a plain label (an `href` cell with an empty href) where no view shows the kind. */
+export type RefCell = DashboardCell | HrefCell;
+/** Kinds the workload view opens, and the apiVersion each has when a reference omits it. */
+export declare const WORKLOAD_KINDS: Readonly<Record<string, string>>;
+/** The k8s-* dashboards, by kind, that the routes below can open. */
+export declare const DASHBOARDS: {
+    readonly pod: 'k8s-pod';
+    readonly workload: 'k8s-workload';
+    readonly maps: 'k8s-maps';
+    readonly volume: 'k8s-volume';
+    readonly class: 'k8s-class';
+    readonly serviceaccount: 'k8s-serviceaccount';
+    readonly crd: 'k8s-crd';
+    readonly rd: 'k8s-rd';
+    readonly namespace: 'k8s-namespace';
+    readonly node: 'k8s-node';
+    readonly service: 'k8s-service';
+    readonly ingress: 'k8s-ingress';
+    readonly resource: 'k8s-resource';
+};
+/** A kind's resource name, as the API guesses it: `Ingress` -> `ingresses`, `Policy` -> `policies`. */
+export declare function plural(kind: string): string;
+/** The API path of an object: `apis/apps/v1/namespaces/db/statefulsets/postgresql`, or `api/v1/nodes/n1`. */
+export declare function apiPath(ref: ObjectRef): string | undefined;
+/** The namespace view. */
+export declare function namespaceRoute(namespace: string): Route;
+/**
+ * The dashboard that shows an object: its own k8s-* view for the kinds that
+ * have one, else the generic resource view (which needs the apiVersion to
+ * build the API path). Undefined when there is neither.
+ */
+export declare function route(ref: ObjectRef): Route | undefined;
+/**
+ * The view of a kind's definition: the CRD view for a custom resource (its
+ * CRD is named `<plural>.<group>`), the resource-definition view for a
+ * built-in kind (which picks it as `<api path>#<Kind>`).
+ */
+export declare function definitionRoute(kind: string, apiVersion: string, resource?: string | null): Route;
+/**
+ * An object as a link cell (`kd-link` data) to its view, with its kind's icon
+ * and a back link to this page. A kind no view shows is a plain label.
+ */
+export declare function refLink(ref: ObjectRef, opt?: LinkOptions): RefCell;
+/** A namespace as a link cell to the namespace view. */
+export declare function namespaceLink(namespace: string, opt?: LinkOptions): DashboardCell;
+/** A kind as a link cell to its definition. */
+export declare function kindLink(kind: string, apiVersion: string, opt?: LinkOptions): DashboardCell;

package/dist/k8s/map.d.ts

@@ -0,0 +1,114 @@
+import type { Cell } from '../kd/cell';
+import type { BarData } from '../kd/elements/bar';
+import type { GroupsData } from '../kd/elements/groups';
+import type { MeterData } from '../kd/elements/meter';
+import type { SheetRow } from '../kd/elements/sheet';
+import type { Step } from '../kd/elements/steps';
+import { type RefCell } from './links';
+export interface OwnerReference {
+    apiVersion?: string;
+    kind: string;
+    name: string;
+    uid?: string;
+    controller?: boolean;
+}
+export interface Condition {
+    type: string;
+    status: 'True' | 'False' | 'Unknown' | string;
+    reason?: string;
+    message?: string;
+    lastTransitionTime?: string;
+}
+export interface ObjectMeta {
+    name?: string;
+    namespace?: string;
+    uid?: string;
+    creationTimestamp?: string;
+    deletionTimestamp?: string;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+    ownerReferences?: OwnerReference[];
+    finalizers?: string[];
+    [key: string]: unknown;
+}
+/** Any Kubernetes API object; only the parts the mappings read are typed. */
+export interface K8sObject {
+    apiVersion?: string;
+    kind?: string;
+    metadata?: ObjectMeta;
+    spec?: any;
+    status?: any;
+    [key: string]: unknown;
+}
+export interface ResourceRequirements {
+    requests?: Record<string, string | number>;
+    limits?: Record<string, string | number>;
+}
+/** A container, or anything with `resources`. */
+export interface ContainerLike {
+    name?: string;
+    resources?: ResourceRequirements;
+}
+/** Options shared by the mappings that show an age. */
+export interface MapOptions {
+    /** The time ages are measured to, in ms; defaults to now. */
+    now?: number;
+    /** Other objects the owner chain may walk through (the ReplicaSet a pod's Deployment owns, say). */
+    related?: K8sObject[];
+}
+/**
+ * A Kubernetes quantity as a plain number in base units: `100m` -> 0.1,
+ * `128Mi` -> 134217728, `1e3` -> 1000, `2E` -> 2e18. NaN when it is not one.
+ */
+export declare function quantity(value: string | number | null | undefined): number;
+/** Seconds as kubectl-ish text: `42s`, `5m`, `3h 12m`, `2d 4h`. */
+export declare function duration(seconds: number): string;
+/** How long ago a timestamp was, or '' without one. */
+export declare function age(iso: string | null | undefined, now?: number): string;
+export interface ResourceMeter {
+    /** `cpu`, `memory`, or any other resource name. */
+    resource: string;
+    data: MeterData;
+}
+/**
+ * One meter per resource a container requests or limits, cpu and memory
+ * first: CPU in millicores, bytes in Ki/Mi/Gi/Ti. `usage` (quantities or base
+ * numbers, by resource name) fills the meter; without it only the marks show.
+ */
+export declare function resources(container: ContainerLike | null | undefined, usage?: Record<string, string | number>): ResourceMeter[];
+/** Condition types that are good when False. */
+export declare const NEGATIVE_CONDITIONS: ReadonlySet<string>;
+/** Whether a condition is in its good state (true), its bad one (false), or unknown (null). */
+export declare function conditionOk(c: Condition): boolean | null;
+/**
+ * The object's conditions as steps, in the order they happen for the kinds
+ * that have one: done when good, failed when bad, warning when unknown. The
+ * time is how long after creation the condition last changed.
+ */
+export declare function conditions(obj: K8sObject | null | undefined): Step[];
+/**
+ * The owner chain, outermost first, as link cells: each owner reference, with
+ * the owners of any owner found in `related` before it. A pod's ReplicaSet
+ * that carries its `pod-template-hash` is preceded by the Deployment it
+ * implies even when the ReplicaSet itself is not at hand.
+ */
+export declare function owners(obj: K8sObject | null | undefined, related?: K8sObject[]): RefCell[];
+/** The labels, for `<kd-groups mode="pills">`. */
+export declare function labels(obj: K8sObject | null | undefined): GroupsData;
+/** Annotations too large and too stale to show: the copy of the object kubectl apply keeps. */
+export declare const HIDDEN_ANNOTATIONS: readonly string[];
+/** The annotations, for `<kd-groups mode="tree">`, without the last-applied copy. */
+export declare function annotations(obj: K8sObject | null | undefined): GroupsData;
+/**
+ * A property sheet of the object, as the k8s views show it: kind (linked to
+ * its definition), namespace, age, owners and uid, then what the kind adds
+ * (a pod's node and IPs, a workload's replicas, a node's addresses and
+ * capacity), then finalizers. Empty rows are left in; `kd-sheet` drops them.
+ */
+export declare function summary(obj: K8sObject | null | undefined, opt?: MapOptions): SheetRow[];
+/** Status pills for the title bar: a pod's phase, readiness and restarts; a node's readiness; else phase, replicas and conditions. */
+export declare function chips(obj: K8sObject | null | undefined): Cell[];
+/** The title bar: the kind's icon, `Kind · namespace` above the name, status pills and the owner chain. */
+export declare function bar(obj: K8sObject | null | undefined, opt?: MapOptions): BarData;
+/** The object without what nobody reads: managedFields and the last-applied copy. */
+export declare function trimmed(obj: K8sObject): K8sObject;