@parallelworks/ui 0.36.0 → 0.37.0

package/dist/editor/index.js

@@ -1,7 +1,11 @@
+import { INPUT_YAML_PATH, JOB_YAML_PATH, SETTINGS_YAML_PATH, STEP_YAML_PATH, settingsSchemas } from "./settingsYaml.js";
 import Editor from "./Editor.js";
 import EditorField from "./EditorField.js";
 import FormCodePanel from "./FormCodePanel.js";
+import { HOST_MARKER_OWNER, LINT_OWNER } from "./lintOwner.js";
+import { nestedWorkflowText } from "./nestedText.js";
+import { revealLines } from "./reveal.js";
 import { defineEditorThemes, getThemeName } from "./themes.js";
 import { setupMonacoWorkers } from "./workers.js";
 import { configureEditorYaml } from "./yaml.js";
-export { Editor, EditorField, FormCodePanel, configureEditorYaml, defineEditorThemes, getThemeName, setupMonacoWorkers };
+export { Editor, EditorField, FormCodePanel, HOST_MARKER_OWNER, INPUT_YAML_PATH, JOB_YAML_PATH, LINT_OWNER, SETTINGS_YAML_PATH, STEP_YAML_PATH, configureEditorYaml, defineEditorThemes, getThemeName, nestedWorkflowText, revealLines, settingsSchemas, setupMonacoWorkers };

package/dist/editor/lintContext.d.ts

@@ -0,0 +1,21 @@
+import type { WorkflowEditing, WorkflowLintContext } from '../editing.js';
+import { type UsesSources } from '../graph/usesInputs.js';
+export { HOST_MARKER_OWNER, LINT_OWNER } from './lintOwner.js';
+export interface LintSources extends UsesSources {
+    secrets?: (() => Promise<string[]>) | undefined;
+    /** `uses` values the host runs itself, which have no workflow to read inputs from. */
+    actions?: Record<string, unknown> | undefined;
+}
+/**
+ * What the linter can't read from `source`: the inputs of each workflow a step uses, and which
+ * of the user's variables are secret, as far as they have arrived. `onMore` runs when more does.
+ */
+export declare function lintContext(editing: WorkflowEditing, source: string, sources: LintSources, onMore: () => void): WorkflowLintContext;
+export declare function useLintSources(): LintSources;
+/** lintContext for a component, which renders again when more of it arrives. */
+export declare function useLintContext(source: string | undefined): WorkflowLintContext;
+/**
+ * The engine's editing once its checks have loaded, rendering again when they have; undefined
+ * before then, without an engine that edits, or with `load` false.
+ */
+export declare function useLintEditing(load?: boolean): WorkflowEditing | undefined;

package/dist/editor/lintContext.js

@@ -0,0 +1,136 @@
+import { useLoadedWorkflowEngine, useRepoSuggestions, useSecretVariablesResolver, useWorkflowActions, useWorkflowJsonResolver } from "../components/Provider.js";
+import { asRecord } from "../graph/records.js";
+import { HOST_MARKER_OWNER, LINT_OWNER } from "./lintOwner.js";
+import { DEFAULT_GITLAB_HOST, DEFAULT_REPO_YAML, loadUsesInputs } from "../graph/usesInputs.js";
+import { useEffect, useMemo, useState } from "react";
+//#region src/editor/lintContext.ts
+var KEEP_MS = 6e4;
+var KEEP_FAILED_MS = 1e4;
+var stale = (kept) => !kept || Date.now() - kept.at > (kept.value === null ? KEEP_FAILED_MS : KEEP_MS);
+function failed(kept) {
+	return kept?.value ? {
+		value: kept.value,
+		at: Date.now() - KEEP_MS + KEEP_FAILED_MS
+	} : {
+		value: null,
+		at: Date.now()
+	};
+}
+var targets = /* @__PURE__ */ new Map();
+var secretNames;
+var waiting = /* @__PURE__ */ new Map();
+var SECRETS = "\0secrets";
+function fetchOnce(key, onMore, load) {
+	const waiters = waiting.get(key);
+	if (waiters) {
+		waiters.add(onMore);
+		return;
+	}
+	const told = /* @__PURE__ */ new Set([onMore]);
+	waiting.set(key, told);
+	load().finally(() => {
+		waiting.delete(key);
+		for (const tell of told) tell();
+	});
+}
+var text = (value, fallback) => typeof value === "string" && value ? value : fallback;
+/**
+* What the linter can't read from `source`: the inputs of each workflow a step uses, and which
+* of the user's variables are secret, as far as they have arrived. `onMore` runs when more does.
+*/
+function lintContext(editing, source, sources, onMore) {
+	let doc;
+	try {
+		doc = editing.loadYaml(source);
+	} catch {
+		doc = void 0;
+	}
+	const wanted = /* @__PURE__ */ new Map();
+	for (const job of Object.values(asRecord(asRecord(doc)["jobs"]))) {
+		const steps = asRecord(job)["steps"];
+		for (const step of Array.isArray(steps) ? steps : []) {
+			const uses = asRecord(step)["uses"];
+			if (typeof uses !== "string" || uses.includes("${{") || Object.hasOwn(sources.actions ?? {}, uses.trim())) continue;
+			const withBlock = asRecord(asRecord(step)["with"]);
+			const key = [
+				uses.trim(),
+				text(withBlock["$yaml"], DEFAULT_REPO_YAML),
+				text(withBlock["$host"], DEFAULT_GITLAB_HOST)
+			].join("\n");
+			wanted.set(uses.trim(), (wanted.get(uses.trim()) ?? /* @__PURE__ */ new Set()).add(key));
+		}
+	}
+	const usesInputs = {};
+	for (const [uses, keys] of wanted) {
+		const key = keys.size === 1 ? [...keys][0] : void 0;
+		if (key === void 0) continue;
+		const kept = targets.get(key);
+		if (kept?.value) usesInputs[uses] = kept.value;
+		if (stale(kept)) {
+			const [, yamlPath = DEFAULT_REPO_YAML, host = DEFAULT_GITLAB_HOST] = key.split("\n");
+			fetchOnce(key, onMore, () => loadUsesInputs(editing, uses, {
+				yamlPath,
+				host
+			}, sources).then((inputs) => {
+				targets.set(key, {
+					value: inputs,
+					at: Date.now()
+				});
+			}, () => {
+				targets.set(key, failed(targets.get(key)));
+			}));
+		}
+	}
+	const secrets = sources.secrets;
+	if (secrets && stale(secretNames)) fetchOnce(SECRETS, onMore, () => secrets().then((names) => {
+		secretNames = {
+			value: names,
+			at: Date.now()
+		};
+	}, () => {
+		secretNames = failed(secretNames);
+	}));
+	return {
+		usesInputs,
+		...secretNames?.value ? { secretVars: secretNames.value } : {}
+	};
+}
+function useLintSources() {
+	const resolve = useWorkflowJsonResolver();
+	const repos = useRepoSuggestions();
+	const secrets = useSecretVariablesResolver();
+	const actions = useWorkflowActions();
+	return useMemo(() => ({
+		resolve,
+		repos,
+		secrets,
+		actions
+	}), [
+		resolve,
+		repos,
+		secrets,
+		actions
+	]);
+}
+/**
+* The engine's editing once its checks have loaded, rendering again when they have; undefined
+* before then, without an engine that edits, or with `load` false.
+*/
+function useLintEditing(load = true) {
+	const engine = useLoadedWorkflowEngine();
+	const [ready, setReady] = useState(() => !!engine?.isReady());
+	useEffect(() => {
+		if (!load || !engine?.editing) return;
+		if (engine.isReady()) {
+			setReady(true);
+			return;
+		}
+		engine.init();
+		return engine.onReady((loaded) => {
+			if (loaded) setReady(true);
+		});
+	}, [load, engine]);
+	return load && ready ? engine?.editing : void 0;
+}
+//#endregion
+export { HOST_MARKER_OWNER, LINT_OWNER, lintContext, useLintEditing, useLintSources };

package/dist/editor/lintOwner.d.ts

@@ -0,0 +1,2 @@
+export declare const LINT_OWNER = "workflowlint";
+export declare const HOST_MARKER_OWNER = "workflowmarkers";

package/dist/editor/lintOwner.js

@@ -0,0 +1,5 @@
+//#region src/editor/lintOwner.ts
+var LINT_OWNER = "workflowlint";
+var HOST_MARKER_OWNER = "workflowmarkers";
+//#endregion
+export { HOST_MARKER_OWNER, LINT_OWNER };

package/dist/editor/nestedText.d.ts

@@ -0,0 +1,13 @@
+/** An editor holding one job or step of a workflow, whose inputs live outside its text. */
+export interface NestedWorkflowText {
+    /** The workflow's inputs, so a new group is named clear of them. */
+    inputs: () => Record<string, unknown>;
+    /** Adds the group of inputs a `with:` completion's expressions read. */
+    addInputs: (name: string, definition: Record<string, unknown>) => void;
+}
+/** Lets completions reach the workflow around the editor of model `uri`; returns the undo. */
+export declare function publishNestedText(uri: string, text: {
+    current: NestedWorkflowText | undefined;
+}): () => void;
+/** The workflow around the editor of model `uri`, or undefined when its text is a whole workflow. */
+export declare function nestedWorkflowText(uri: string): NestedWorkflowText | undefined;

package/dist/editor/nestedText.js

@@ -0,0 +1,15 @@
+//#region src/editor/nestedText.ts
+var published = /* @__PURE__ */ new Map();
+/** Lets completions reach the workflow around the editor of model `uri`; returns the undo. */
+function publishNestedText(uri, text) {
+	published.set(uri, text);
+	return () => {
+		if (published.get(uri) === text) published.delete(uri);
+	};
+}
+/** The workflow around the editor of model `uri`, or undefined when its text is a whole workflow. */
+function nestedWorkflowText(uri) {
+	return published.get(uri)?.current;
+}
+//#endregion
+export { nestedWorkflowText, publishNestedText };

package/dist/editor/reveal.d.ts

@@ -0,0 +1,4 @@
+/** Lets revealLines reach the editor showing `path`; returns the function that undoes it. */
+export declare function registerRevealer(path: string, reveal: (start: number, end: number) => void): () => void;
+/** Scrolls the editor showing `path` to 1-based lines `start`–`end` and flashes them. */
+export declare function revealLines(path: string, start: number, end: number): void;

package/dist/editor/reveal.js

@@ -0,0 +1,15 @@
+//#region src/editor/reveal.ts
+var revealers = /* @__PURE__ */ new Map();
+/** Lets revealLines reach the editor showing `path`; returns the function that undoes it. */
+function registerRevealer(path, reveal) {
+	revealers.set(path, reveal);
+	return () => {
+		if (revealers.get(path) === reveal) revealers.delete(path);
+	};
+}
+/** Scrolls the editor showing `path` to 1-based lines `start`–`end` and flashes them. */
+function revealLines(path, start, end) {
+	revealers.get(path)?.(start, end);
+}
+//#endregion
+export { registerRevealer, revealLines };

package/dist/editor/settingsYaml.d.ts

@@ -0,0 +1,12 @@
+/** Editors holding one job's, step's or input's settings, each checked against that part of the workflow schema. */
+export declare const JOB_YAML_PATH = "file:///workflow-job.yaml";
+export declare const STEP_YAML_PATH = "file:///workflow-step.yaml";
+export declare const INPUT_YAML_PATH = "file:///workflow-input.yaml";
+export declare const SETTINGS_YAML_PATH = "file:///workflow-settings.yaml";
+export type JsonSchema = Record<string, unknown>;
+export declare function settingsSchemas(workflow: JsonSchema): {
+    job: JsonSchema;
+    step: JsonSchema;
+    input: JsonSchema;
+    settings: JsonSchema;
+};

package/dist/editor/settingsYaml.js

@@ -0,0 +1,41 @@
+//#region src/editor/settingsYaml.ts
+/** Editors holding one job's, step's or input's settings, each checked against that part of the workflow schema. */
+var JOB_YAML_PATH = "file:///workflow-job.yaml";
+var STEP_YAML_PATH = "file:///workflow-step.yaml";
+var INPUT_YAML_PATH = "file:///workflow-input.yaml";
+var SETTINGS_YAML_PATH = "file:///workflow-settings.yaml";
+var record = (value) => typeof value === "object" && value !== null ? value : {};
+function settingsSchemas(workflow) {
+	const patterns = record(record(record(workflow["properties"])["jobs"])["patternProperties"]);
+	const job = record(Object.values(patterns)[0]);
+	const step = record(record(record(job["properties"])["steps"])["items"]);
+	const inputs = record(record(record(workflow["$defs"])["inputs"])["patternProperties"]);
+	const input = record(Object.values(inputs)[0]);
+	const shared = {
+		$schema: workflow["$schema"],
+		$defs: workflow["$defs"]
+	};
+	const { jobs: _jobs, on: _on, ...settings } = record(workflow["properties"]);
+	return {
+		job: {
+			...job,
+			...shared
+		},
+		step: {
+			...step,
+			...shared
+		},
+		input: {
+			...input,
+			...shared
+		},
+		settings: {
+			type: "object",
+			properties: settings,
+			additionalProperties: false,
+			...shared
+		}
+	};
+}
+//#endregion
+export { INPUT_YAML_PATH, JOB_YAML_PATH, SETTINGS_YAML_PATH, STEP_YAML_PATH, settingsSchemas };

package/dist/form/Fields/DropdownField.js

@@ -1,7 +1,7 @@
 import { FieldWrapper } from "../FieldWrapper.js";
 import FormikCustomDropdown_default from "../SpecialTypes/FormikCustomDropdown.js";
-import { getPlaceholder } from "../utils/getPlaceholder.js";
 import { dependentOptions } from "../utils/dependentOptions.js";
+import { getPlaceholder } from "../utils/getPlaceholder.js";
 import { jsx } from "react/jsx-runtime";
 //#region src/form/Fields/DropdownField.tsx
 var missingSetter = () => {

package/dist/form/Fields/DurationField.js

@@ -1,7 +1,7 @@
 import { useStrings } from "../../components/Provider.js";
 import { FieldWrapper } from "../FieldWrapper.js";
-import { setDurationValidity } from "./durationValidity.js";
 import { formatDuration, parseDuration } from "../utils/duration.js";
+import { setDurationValidity } from "./durationValidity.js";
 import cx from "classnames";
 import { memo, useEffect, useRef, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";

package/dist/form/Form.js

@@ -9,9 +9,9 @@ import SectionHeader from "../components/SectionHeader.js";
 import { Table } from "../components/Table.js";
 import { parseWizardConfig } from "./Wizard/utils.js";
 import { inputWidth, resolvedFlag } from "./lib.js";
-import { useFieldControlProps, useFieldRequired } from "./fieldContext.js";
 import { resolveFormLayout } from "./layout.js";
 import { FormLayout, LayoutCSSContext } from "./FormLayout.js";
+import { useFieldControlProps, useFieldRequired } from "./fieldContext.js";
 import { getValueUsingPath } from "./utils/getValueUsingPath.js";
 import { FieldRegistryContext, Registry } from "./fieldRegistry.js";
 import { useParsedOpts } from "./useParsedOpts.js";

package/dist/form/fieldRegistry.js

@@ -1,5 +1,4 @@
 import { useSlots } from "../components/Provider.js";
-import NumberField from "./Fields/NumberField.js";
 import BooleanField from "./Fields/BooleanField.js";
 import CheckboxGroupField from "./Fields/CheckboxGroupField.js";
 import ColorField from "./Fields/ColorField.js";
@@ -7,6 +6,7 @@ import DropdownField from "./Fields/DropdownField.js";
 import DurationField_default from "./Fields/DurationField.js";
 import LabelField from "./Fields/LabelField.js";
 import MultiDropdownField from "./Fields/MultiDropdownField.js";
+import NumberField from "./Fields/NumberField.js";
 import ObjectField from "./Fields/ObjectField.js";
 import RadioField from "./Fields/RadioField.js";
 import RangeField from "./Fields/RangeField.js";

package/dist/form/index.js

@@ -1,20 +1,20 @@
 import { applySecondaryField, findSecondaryOption } from "./utils/secondaryField.js";
 import { enforceOneMustBeTrue, flattenGroups, impureSetValueFromPath, initializeValues, resolvedFlag } from "./lib.js";
+import { resolveFormLayout } from "./layout.js";
+import { resolveLayoutCSS } from "./layoutCSS.js";
 import { FieldProvider, useFieldControlProps, useFieldLabelledByProps, useFieldRequired } from "./fieldContext.js";
 import { FieldWrapper } from "./FieldWrapper.js";
-import { getInvalidDurationPaths, setDurationValidity } from "./Fields/durationValidity.js";
 import FormikCustomDropdown_default from "./SpecialTypes/FormikCustomDropdown.js";
 import FormikCustomInput from "./SpecialTypes/FormikCustomInput.js";
 import FormikNumericInput from "./SpecialTypes/FormikNumericInput.js";
 import { getPlaceholder } from "./utils/getPlaceholder.js";
-import NumberField from "./Fields/NumberField.js";
-import { ResourceOptionIcon } from "./Fields/ResourceOptionIcon.js";
-import { resolveFormLayout } from "./layout.js";
-import { resolveLayoutCSS } from "./layoutCSS.js";
 import { FLEX_MAX_DURATION_RANGE, FLEX_WAIT_TIME_RANGE, STANDARD_MAX_DURATION_RANGE, collectPartitionDurationIssues, formatDuration, parseDuration } from "./utils/duration.js";
+import { getInvalidDurationPaths, setDurationValidity } from "./Fields/durationValidity.js";
+import NumberField from "./Fields/NumberField.js";
 import { FieldRegistryContext, Registry } from "./fieldRegistry.js";
 import { useParsedOpts } from "./useParsedOpts.js";
 import { DynamicDefaultsSync, DynamicForm, FieldsFromOptions, GroupHeader, MultiSelectionDropdown, collectFieldsWithDefaults, findSelfReferencingFieldNames, resolveMetaOverrides, useDynamicDefaultsSync } from "./Form.js";
+import { ResourceOptionIcon } from "./Fields/ResourceOptionIcon.js";
 import DropdownWrapper from "./SpecialTypes/DropdownWrapper.js";
 import FormikMultiSelectDropdown from "./SpecialTypes/FormikMultiSelectDropdown.js";
 export { DropdownWrapper, DynamicDefaultsSync, DynamicForm, FLEX_MAX_DURATION_RANGE, FLEX_WAIT_TIME_RANGE, FieldProvider, FieldRegistryContext, FieldWrapper, FieldsFromOptions, FormikCustomDropdown_default as FormikCustomDropdown, FormikCustomInput, FormikMultiSelectDropdown, FormikNumericInput, GroupHeader, MultiSelectionDropdown, NumberField, Registry, ResourceOptionIcon, STANDARD_MAX_DURATION_RANGE, applySecondaryField, collectFieldsWithDefaults, collectPartitionDurationIssues, enforceOneMustBeTrue, findSecondaryOption, findSelfReferencingFieldNames, flattenGroups, formatDuration, getInvalidDurationPaths, getPlaceholder, impureSetValueFromPath, initializeValues, parseDuration, resolveFormLayout, resolveLayoutCSS, resolveMetaOverrides, resolvedFlag, setDurationValidity, useDynamicDefaultsSync, useFieldControlProps, useFieldLabelledByProps, useFieldRequired, useParsedOpts };

package/dist/graph/InputDialog.d.ts

@@ -0,0 +1,80 @@
+import { type ReactNode } from 'react';
+import type { FieldPatch, GraphEdit, InputPath, WorkflowEditing } from '../editing.js';
+import { type Json, type OpenOnAdd } from './editorFields.js';
+import { type InputsEditorStrings } from './editorStrings.js';
+import { type InputSource } from './inputRefs.js';
+import type { SettingsView } from './settingsViews.js';
+/** Input types by menu group, in the order the add menu lists them. */
+export declare const INPUT_TYPE_GROUPS: [keyof InputsEditorStrings['typeGroups'], string[]][];
+declare const TEXT_FIELDS: readonly ['label', 'description', 'tooltip'];
+declare const FLAG_FIELDS: readonly ['optional', 'hidden', 'disabled', 'ignore'];
+type CommonKey = (typeof TEXT_FIELDS)[number] | (typeof FLAG_FIELDS)[number];
+export declare function inputTypes(): string[];
+export declare function commonKeys(type: string): CommonKey[];
+/** Every key the dialog can write for an input of `type`. */
+export declare function offeredInputKeys(editing: WorkflowEditing, type: string): string[];
+/** The starting definition of a new input of `type`, with what the schema requires. */
+export declare function newInputDefinition(type: string): Json;
+/** An input a dialog creates when it saves, for a field that reads it. */
+export interface PendingInput {
+    name: string;
+    definition: Json;
+}
+export declare function allNames(editing: WorkflowEditing, map: Json, out: Set<string>): Set<string>;
+/** Where a dialog puts the inputs it creates: the top level, or one wizard step. */
+export interface InputHome {
+    parent: string[];
+    index?: number;
+}
+/** `edit` after the edits that add `created` at `home`, as one undo step. */
+export declare function withCreatedInputs(editing: WorkflowEditing, created: PendingInput[], home: InputHome, edit: GraphEdit | null): GraphEdit | null;
+export interface NewInputs {
+    source: InputSource;
+    all: Json;
+    home: InputHome;
+    pending: PendingInput[];
+    adopt: (created: PendingInput[]) => void;
+    dialog: ReactNode;
+    /** The form's edit with the inputs it made, or null when there's nothing to save. */
+    save: (edit: GraphEdit | null) => GraphEdit | null;
+}
+/** Inputs a dialog's fields can read, plus the ones it creates on save. */
+export declare function useNewInputs(inputs: Json | undefined, home?: InputHome): NewInputs;
+/** Every setting of one input; `onSave` gets the whole definition and the change to it. */
+interface InputDialogProps {
+    name: string;
+    definition: Json;
+    isNew: boolean;
+    /** Names already taken in the same container. */
+    siblings: string[];
+    allowStep: boolean;
+    /** The workflow's inputs, for settings that read another input. */
+    inputs?: Json | undefined;
+    /** Where inputs made for this dialog's settings will go. */
+    home?: InputHome | undefined;
+    /** A new input made for one field keeps the type that field needs. */
+    lockedType?: boolean;
+    /** `created` are inputs this dialog made for its own settings. */
+    onSave: (name: string, definition: Json, patch: Required<FieldPatch>, created: PendingInput[]) => void;
+    onDelete?: () => void;
+    onClose: () => void;
+    openOnAdd?: OpenOnAdd | undefined;
+}
+/** Saving an input as YAML text; `path` and `source` give an existing input's text with its comments. */
+export interface InputYaml {
+    source?: string | undefined;
+    path?: InputPath | undefined;
+    /** `created` are the inputs the form made for its settings before switching to the YAML. */
+    onSave: (name: string, yaml: string, created: PendingInput[]) => void;
+}
+/** An input's settings in a form, or as YAML when `yaml` says how to save it; switching carries the edits across. */
+export declare function InputDialog({ yaml, view, onViewChange, ...props }: InputDialogProps & {
+    yaml?: InputYaml | undefined;
+    view?: SettingsView | undefined;
+    onViewChange?: ((view: SettingsView) => void) | undefined;
+}): import("react").JSX.Element;
+/** A compact type chip for rows that list inputs. */
+export declare function TypeBadge({ type }: {
+    type: string;
+}): import("react").JSX.Element;
+export {};