@kubed.io/cdn 0.0.3 → 0.0.4

package/dist/openapi/model.d.ts

@@ -0,0 +1,154 @@
+/** A raw schema object, as it appears in the document. */
+export type Schema = Record<string, unknown>;
+/** An OpenAPI v3 document, or any JSON document that holds schemas. */
+export interface OpenApiDocument {
+    components?: {
+        schemas?: Record<string, Schema>;
+    };
+    [key: string]: unknown;
+}
+/** One `x-kubernetes-validations` entry: a CEL rule. */
+export interface Validation {
+    rule: string;
+    message?: string;
+    messageExpression?: string;
+    reason?: string;
+    fieldPath?: string;
+    optionalOldSelf?: boolean;
+}
+/** One `x-kubernetes-group-version-kind` entry. */
+export interface GroupVersionKind {
+    group: string;
+    version: string;
+    kind: string;
+}
+/** One `x-kubernetes-unions` entry. */
+export interface Union {
+    discriminator?: string;
+    'fields-to-discriminateBy'?: Record<string, string>;
+}
+/**
+ * Every keyword the model knows, typed. Values are the document's own, after
+ * `$ref` resolution and the `allOf` merge; nothing is rewritten. Kubernetes'
+ * `x-kubernetes-*` extensions are OpenAPI extensions, so they are known here
+ * like any other keyword.
+ */
+export interface Keywords {
+    $ref?: string;
+    type?: string | string[];
+    title?: string;
+    description?: string;
+    format?: string;
+    pattern?: string;
+    default?: unknown;
+    enum?: unknown[];
+    const?: unknown;
+    example?: unknown;
+    examples?: unknown[];
+    minimum?: number;
+    maximum?: number;
+    /** A boolean in OpenAPI 3.0, a number in JSON Schema 2019+. */
+    exclusiveMinimum?: boolean | number;
+    exclusiveMaximum?: boolean | number;
+    multipleOf?: number;
+    minLength?: number;
+    maxLength?: number;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    minProperties?: number;
+    maxProperties?: number;
+    nullable?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    deprecated?: boolean;
+    externalDocs?: {
+        url?: string;
+        description?: string;
+    };
+    required?: string[];
+    properties?: Record<string, Schema>;
+    items?: Schema | Schema[];
+    additionalProperties?: boolean | Schema;
+    allOf?: Schema[];
+    anyOf?: Schema[];
+    oneOf?: Schema[];
+    not?: Schema;
+    'x-kubernetes-int-or-string'?: boolean;
+    'x-kubernetes-preserve-unknown-fields'?: boolean;
+    'x-kubernetes-embedded-resource'?: boolean;
+    'x-kubernetes-list-type'?: 'atomic' | 'set' | 'map' | string;
+    'x-kubernetes-list-map-keys'?: string[];
+    'x-kubernetes-map-type'?: 'atomic' | 'granular' | string;
+    'x-kubernetes-validations'?: Validation[];
+    'x-kubernetes-patch-strategy'?: string;
+    'x-kubernetes-patch-merge-key'?: string;
+    'x-kubernetes-unions'?: Union[];
+    'x-kubernetes-group-version-kind'?: GroupVersionKind[];
+}
+/** The names of every known keyword, in display order. */
+export declare const KEYWORDS: readonly (keyof Keywords)[];
+/**
+ * A node of the schema tree: a field, the root, or the item/value schema of a
+ * list/map.
+ *
+ * Children (`properties`, `items`, `values`, `fields`) are computed when first
+ * read and then kept, so normalizing a root costs one node and a viewer pays
+ * only for what it opens. `parent` and `cycle` are getters, so a node
+ * serialises as plain data without looping.
+ *
+ * Recursion is cut, never depth-limited: a node whose type is already open
+ * above it has `cycle` set to that ancestor and no children.
+ */
+export interface SchemaNode {
+    /** `root` (what normalize returns), `field` (a property), `item` (an array's items), `value` (a map's values). */
+    readonly role: 'root' | 'field' | 'item' | 'value';
+    /** The property name; `''` for the root, an item or a value. */
+    readonly name: string;
+    /** The path as kubectl explain spells it (`spec.template.spec.containers.name`); items and values share their owner's. */
+    readonly path: string;
+    /** Listed in the owning object's `required`. */
+    readonly required: boolean;
+    /** The display type in kubectl explain's spelling: `string`, `Object`, `[]Container`, `map[string]string`, `int-or-string`, `any`. */
+    readonly type: string;
+    /** The short name of the type it was referenced as (`PodSpec` for `io.k8s.api.core.v1.PodSpec`). */
+    readonly typeName?: string;
+    /** The full name of the schema `$ref`/`allOf` brought in (`io.k8s.api.core.v1.PodSpec`). */
+    readonly ref?: string;
+    /** The schema after `$ref` resolution and the `allOf` merge; the node's own keywords win. */
+    readonly schema: Schema;
+    /** The known keywords of `schema`. */
+    readonly keywords: Keywords;
+    /** Every keyword of `schema` the model does not know, raw. */
+    readonly other: Record<string, unknown>;
+    /** The node it belongs to; the root has none. */
+    readonly parent: SchemaNode | undefined;
+    /** When this node's type is open in an ancestor, that ancestor. Its children are listed there, not here. */
+    readonly cycle: SchemaNode | undefined;
+    /** The object's own properties, in document order. */
+    readonly properties: readonly SchemaNode[];
+    /** An array's item schema. */
+    readonly items: SchemaNode | undefined;
+    /** A map's value schema (an `additionalProperties` schema). */
+    readonly values: SchemaNode | undefined;
+    /** The children kubectl explain lists: the properties, else the items' fields, else the values' fields. */
+    readonly fields: readonly SchemaNode[];
+    /** Whether `fields` is non-empty. */
+    readonly expandable: boolean;
+}
+/** A root: a component name (`X` or `#/components/schemas/X`, or a unique `.X` suffix), any `#/` pointer, a schema, a CRD version, or a CRD. */
+export type Root = string | Schema;
+/** The short name of a component, as kubectl explain shows it: `io.k8s.api.core.v1.PodSpec` -> `PodSpec`. */
+export declare function shortName(ref: string): string;
+/**
+ * The schema tree of `root` in `document`. Only the root is built; every other
+ * node is built when its parent's children are first read.
+ *
+ * @param document an OpenAPI v3 document (its `components.schemas` resolve `$ref`), a CRD, or a bare schema
+ * @param root a component name (`io.k8s.api.apps.v1.Deployment`, `#/components/schemas/...`, or a unique suffix
+ *   such as `apps.v1.Deployment`), a `#/` pointer, a schema object, a CRD version (`{schema: {openAPIV3Schema}}`)
+ *   or its `openAPIV3Schema`; omitted, the document itself (a CRD: its storage version)
+ */
+export declare function normalize(document: unknown, root?: Root): SchemaNode;
+/** The node at a dotted field path below `node` (`spec.template.spec.containers.name`), or undefined. */
+export declare function find(node: SchemaNode, path: string): SchemaNode | undefined;

package/dist/openapi/schema.d.ts

@@ -0,0 +1,52 @@
+import { type PropertyValues, type TemplateResult } from 'lit';
+import { KdElement } from '../kd/element';
+import { type Root } from './model';
+/**
+ * An OpenAPI v3 / JSON Schema viewer, written the way the YAML is: a field per
+ * line with its type, constraints and Kubernetes behaviours beside it, a
+ * required marker, and the description, rules and fields when opened. A
+ * subtree is rendered only when it is opened.
+ *
+ * Data in: `document` (an OpenAPI document, a CRD or a schema) and `root` (see
+ * `normalize`) as properties, or `src`, a URL returning the document.
+ *
+ * Attributes: `root`, `src`, `expand` (top-level fields open at first, default
+ * `spec status`), `omit` (top-level fields left out, e.g. `apiVersion kind metadata`).
+ */
+export declare class KdSchema extends KdElement {
+    #private;
+    static properties: {
+        document: {
+            attribute: boolean;
+        };
+        root: {
+            attribute: string;
+        };
+        src: {
+            attribute: string;
+        };
+        expand: {
+            attribute: string;
+        };
+        omit: {
+            attribute: string;
+        };
+        error: {
+            state: boolean;
+        };
+    };
+    document: unknown;
+    root: Root | undefined;
+    src: string | undefined;
+    expand: string | undefined;
+    omit: string | undefined;
+    error: string | undefined;
+    static styles: import("lit").CSSResult[];
+    protected willUpdate(changed: PropertyValues<this>): void;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'kd-schema': KdSchema;
+    }
+}