@k8slens/extensions 6.1.1-git.e8f691ab0e.0 → 6.1.1-git.ed073d6562.0

package/dist/src/common/cluster/cluster.d.ts

@@ -189,7 +189,7 @@ export declare class Cluster implements ClusterModel, ClusterState {
      * @internal
      */
     get defaultNamespace(): string | undefined;
-    constructor(dependencies: ClusterDependencies, model: ClusterModel, configData: ClusterConfigData);
+    constructor(dependencies: ClusterDependencies, { id, ...model }: ClusterModel, configData: ClusterConfigData);
     /**
      * Update cluster data model
      *

package/dist/src/common/cluster-store/get-by-id.injectable.d.ts

@@ -0,0 +1,5 @@
+import type { ClusterId } from "../cluster-types";
+import type { Cluster } from "../cluster/cluster";
+export declare type GetClusterById = (id: ClusterId) => Cluster | undefined;
+declare const getClusterByIdInjectable: import("@ogre-tools/injectable").Injectable<GetClusterById, unknown, void>;
+export default getClusterByIdInjectable;

package/dist/src/common/cluster-types.d.ts

@@ -2,6 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
+import Joi from "joi";
 /**
  * JSON serializable metadata type
  */
@@ -22,6 +23,15 @@ export declare type ClusterId = string;
  * The fields that are used for updating a cluster instance
  */
 export declare type UpdateClusterModel = Omit<ClusterModel, "id">;
+/**
+ * A type validator for `UpdateClusterModel` so that only expected types are present
+ */
+export declare const updateClusterModelChecker: Joi.ObjectSchema<UpdateClusterModel>;
+/**
+ * A type validator for just the `id` fields of `ClusterModel`. The rest is
+ * covered by `updateClusterModelChecker`
+ */
+export declare const clusterModelIdChecker: Joi.ObjectSchema<Pick<ClusterModel, "id">>;
 /**
  * The model for passing cluster data around, including to disk
  */

package/dist/src/common/fs/create-read-file-stream.injectable.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { ReadStream } from "fs";
+export interface CreateReadStreamOptions {
+    mode?: number;
+    end?: number | undefined;
+    flags?: string | undefined;
+    encoding?: BufferEncoding | undefined;
+    autoClose?: boolean | undefined;
+    /**
+     * @default false
+     */
+    emitClose?: boolean | undefined;
+    start?: number | undefined;
+    highWaterMark?: number | undefined;
+}
+export declare type CreateReadFileStream = (filePath: string, options?: CreateReadStreamOptions) => ReadStream;
+declare const createReadFileStreamInjectable: import("@ogre-tools/injectable").Injectable<CreateReadFileStream, unknown, void>;
+export default createReadFileStreamInjectable;

package/dist/src/common/fs/stat/stat.global-override-for-injectable.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
-    injectable: import("@ogre-tools/injectable").Injectable<typeof import("fs-extra").stat, unknown, void>;
-    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<typeof import("fs-extra").stat, void>;
+    injectable: import("@ogre-tools/injectable").Injectable<import("./stat.injectable").Stat, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<import("./stat.injectable").Stat, void>;
 };
 export default _default;

package/dist/src/common/fs/stat/stat.injectable.d.ts

@@ -1,2 +1,5 @@
-declare const statInjectable: import("@ogre-tools/injectable").Injectable<typeof import("fs-extra").stat, unknown, void>;
+/// <reference types="node" />
+import type { Stats } from "fs";
+export declare type Stat = (path: string) => Promise<Stats>;
+declare const statInjectable: import("@ogre-tools/injectable").Injectable<Stat, unknown, void>;
 export default statInjectable;

package/dist/src/common/fs/watch/watch.injectable.d.ts

@@ -1,4 +1,122 @@
-import type { FSWatcher, WatchOptions } from "chokidar";
-export declare type Watch = (path: string, options?: WatchOptions) => FSWatcher;
+/// <reference types="node" />
+import type { Stats } from "fs";
+import type TypedEventEmitter from "typed-emitter";
+import type { SingleOrMany } from "../../utils";
+export interface AlwaysStatWatcherEvents {
+    add: (path: string, stats: Stats) => void;
+    addDir: (path: string, stats: Stats) => void;
+    change: (path: string, stats: Stats) => void;
+}
+export interface MaybeStatWatcherEvents {
+    add: (path: string, stats?: Stats) => void;
+    addDir: (path: string, stats?: Stats) => void;
+    change: (path: string, stats?: Stats) => void;
+}
+export declare type WatcherEvents<AlwaysStat extends boolean> = BaseWatcherEvents & (AlwaysStat extends true ? AlwaysStatWatcherEvents : MaybeStatWatcherEvents);
+export interface BaseWatcherEvents {
+    error: (error: Error) => void;
+    ready: () => void;
+    unlink: (path: string) => void;
+    unlinkDir: (path: string) => void;
+}
+export interface Watcher<AlwaysStat extends boolean> extends TypedEventEmitter<WatcherEvents<AlwaysStat>> {
+    close: () => Promise<void>;
+}
+export declare type WatcherOptions<AlwaysStat extends boolean> = {
+    /**
+     * Indicates whether the process should continue to run as long as files are being watched. If
+     * set to `false` when using `fsevents` to watch, no more events will be emitted after `ready`,
+     * even if the process continues to run.
+     */
+    persistent?: boolean;
+    /**
+     * ([anymatch](https://github.com/micromatch/anymatch)-compatible definition) Defines files/paths to
+     * be ignored. The whole relative or absolute path is tested, not just filename. If a function
+     * with two arguments is provided, it gets called twice per path - once with a single argument
+     * (the path), second time with two arguments (the path and the
+     * [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) object of that path).
+     */
+    ignored?: SingleOrMany<string | RegExp | ((path: string) => boolean)>;
+    /**
+     * If set to `false` then `add`/`addDir` events are also emitted for matching paths while
+     * instantiating the watching as chokidar discovers these file paths (before the `ready` event).
+     */
+    ignoreInitial?: boolean;
+    /**
+     * When `false`, only the symlinks themselves will be watched for changes instead of following
+     * the link references and bubbling events through the link's path.
+     */
+    followSymlinks?: boolean;
+    /**
+     * The base directory from which watch `paths` are to be derived. Paths emitted with events will
+     * be relative to this.
+     */
+    cwd?: string;
+    /**
+     *  If set to true then the strings passed to .watch() and .add() are treated as literal path
+     *  names, even if they look like globs. Default: false.
+     */
+    disableGlobbing?: boolean;
+    /**
+     * Whether to use fs.watchFile (backed by polling), or fs.watch. If polling leads to high CPU
+     * utilization, consider setting this to `false`. It is typically necessary to **set this to
+     * `true` to successfully watch files over a network**, and it may be necessary to successfully
+     * watch files in other non-standard situations. Setting to `true` explicitly on OS X overrides
+     * the `useFsEvents` default.
+     */
+    usePolling?: boolean;
+    /**
+     * Whether to use the `fsevents` watching interface if available. When set to `true` explicitly
+     * and `fsevents` is available this supercedes the `usePolling` setting. When set to `false` on
+     * OS X, `usePolling: true` becomes the default.
+     */
+    useFsEvents?: boolean;
+    /**
+     * If set, limits how many levels of subdirectories will be traversed.
+     */
+    depth?: number;
+    /**
+     * Interval of file system polling.
+     */
+    interval?: number;
+    /**
+     * Interval of file system polling for binary files. ([see list of binary extensions](https://gi
+     * thub.com/sindresorhus/binary-extensions/blob/master/binary-extensions.json))
+     */
+    binaryInterval?: number;
+    /**
+     *  Indicates whether to watch files that don't have read permissions if possible. If watching
+     *  fails due to `EPERM` or `EACCES` with this set to `true`, the errors will be suppressed
+     *  silently.
+     */
+    ignorePermissionErrors?: boolean;
+    /**
+     * `true` if `useFsEvents` and `usePolling` are `false`). Automatically filters out artifacts
+     * that occur when using editors that use "atomic writes" instead of writing directly to the
+     * source file. If a file is re-added within 100 ms of being deleted, Chokidar emits a `change`
+     * event rather than `unlink` then `add`. If the default of 100 ms does not work well for you,
+     * you can override it by setting `atomic` to a custom value, in milliseconds.
+     */
+    atomic?: boolean | number;
+    /**
+     * can be set to an object in order to adjust timing params:
+     */
+    awaitWriteFinish?: AwaitWriteFinishOptions | boolean;
+} & (AlwaysStat extends true ? {
+    alwaysStat: true;
+} : {
+    alwaysStat?: false;
+});
+export interface AwaitWriteFinishOptions {
+    /**
+     * Amount of time in milliseconds for a file size to remain constant before emitting its event.
+     */
+    stabilityThreshold?: number;
+    /**
+     * File size polling interval.
+     */
+    pollInterval?: number;
+}
+export declare type Watch = <AlwaysStat extends boolean = false>(path: string, options?: WatcherOptions<AlwaysStat>) => Watcher<AlwaysStat>;
 declare const watchInjectable: import("@ogre-tools/injectable").Injectable<Watch, unknown, void>;
 export default watchInjectable;

package/dist/src/common/logger/prefixed-logger.injectable.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from "../logger";
+declare const prefixedLoggerInjectable: import("@ogre-tools/injectable").Injectable<Logger, unknown, string>;
+export default prefixedLoggerInjectable;

package/dist/src/common/runnable/run-many-for.d.ts

@@ -1,7 +1,8 @@
 import type { DiContainerForInjection, InjectionToken } from "@ogre-tools/injectable";
 export interface Runnable<TParameter = void> {
+    id: string;
     run: Run<TParameter>;
-    runAfter?: this;
+    runAfter?: Runnable<TParameter>;
 }
 declare type Run<Param> = (parameter: Param) => Promise<void> | void;
 export declare type RunMany = <Param>(injectionToken: InjectionToken<Runnable<Param>, void>) => Run<Param>;

package/dist/src/common/runnable/run-many-sync-for.d.ts

@@ -1,8 +1,9 @@
 import type { DiContainerForInjection, InjectionToken } from "@ogre-tools/injectable";
 import type { Runnable } from "./run-many-for";
 export interface RunnableSync<TParameter = void> {
+    id: string;
     run: RunSync<TParameter>;
-    runAfter?: this;
+    runAfter?: RunnableSync<TParameter>;
 }
 declare type RunSync<Param> = (parameter: Param) => void;
 export declare type RunManySync = <Param>(injectionToken: InjectionToken<Runnable<Param>, void>) => RunSync<Param>;

package/dist/src/common/runnable/throw-with-incorrect-hierarchy-for.d.ts

@@ -4,4 +4,4 @@
  */
 import type { Runnable } from "./run-many-for";
 import type { RunnableSync } from "./run-many-sync-for";
-export declare const throwWithIncorrectHierarchyFor: (allRunnables: Runnable<any>[] | RunnableSync<any>[]) => (runnable: Runnable<any> | RunnableSync<any>) => void;
+export declare const throwWithIncorrectHierarchyFor: (injectionTokenId: string, allRunnables: Runnable<any>[] | RunnableSync<any>[]) => (runnable: Runnable<any> | RunnableSync<any>) => void;

package/dist/src/common/user-store/kubeconfig-syncs.injectable.d.ts

@@ -0,0 +1,2 @@
+declare const kubeconfigSyncsInjectable: import("@ogre-tools/injectable").Injectable<import("mobx").ObservableMap<string, import("./preferences-helpers").KubeconfigSyncValue>, unknown, void>;
+export default kubeconfigSyncsInjectable;

package/dist/src/common/utils/iter.d.ts

@@ -9,6 +9,7 @@ interface Iterator<T> {
     find(fn: (val: T) => unknown): T | undefined;
     collect<U>(fn: (values: Iterable<T>) => U): U;
     map<U>(fn: (val: T) => U): Iterator<U>;
+    flatMap<U>(fn: (val: T) => U[]): Iterator<U>;
     join(sep?: string): string;
 }
 export declare function pipeline<T>(src: IterableIterator<T>): Iterator<T>;