@prefecthq/prefect-ui-library 2.4.30 → 2.4.32

package/dist/types/src/index.d.ts

@@ -10,6 +10,7 @@ export * from './router';
 export * from './services';
 export * from './types';
 export * from './utilities';
+export * from './schemas';
 import '@/styles/style.css';
 import { Plugin } from 'vue';
 declare const plugin: Plugin;

package/dist/types/src/schemas/components/SchemaForm.vue.d.ts

@@ -0,0 +1,23 @@
+import { Schema } from '../../schemas/types/schema';
+import { SchemaValues } from '../../schemas/types/schemaValues';
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    schema: Schema;
+    values: SchemaValues;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:values": (args_0: SchemaValues) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    schema: Schema;
+    values: SchemaValues;
+}>>> & {
+    "onUpdate:values"?: ((args_0: SchemaValues) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/src/schemas/components/SchemaFormKindInput.vue.d.ts

@@ -0,0 +1,23 @@
+import { SchemaProperty } from '../../schemas/types/schema';
+import { PrefectKindValue } from '../../schemas/types/schemaValues';
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    property: SchemaProperty;
+    value: PrefectKindValue;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:value": (args_0: PrefectKindValue) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    property: SchemaProperty;
+    value: PrefectKindValue;
+}>>> & {
+    "onUpdate:value"?: ((args_0: PrefectKindValue) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/src/schemas/components/SchemaFormProperties.vue.d.ts

@@ -0,0 +1,25 @@
+import { SchemaProperty, SchemaProperties } from '../../schemas/types/schema';
+import { SchemaValues } from '../../schemas/types/schemaValues';
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    parent: SchemaProperty;
+    properties: SchemaProperties;
+    values: SchemaValues;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:values": (args_0: SchemaValues) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    parent: SchemaProperty;
+    properties: SchemaProperties;
+    values: SchemaValues;
+}>>> & {
+    "onUpdate:values"?: ((args_0: SchemaValues) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/src/schemas/components/SchemaFormProperty.vue.d.ts

@@ -0,0 +1,25 @@
+import { SchemaProperty } from '../../schemas/types/schema';
+import { SchemaValue } from '../../schemas/types/schemaValues';
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    property: SchemaProperty;
+    value: SchemaValue;
+    required: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:value": (args_0: unknown) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    property: SchemaProperty;
+    value: SchemaValue;
+    required: boolean;
+}>>> & {
+    "onUpdate:value"?: ((args_0: unknown) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/src/schemas/components/SchemaFormPropertyAllOf.vue.d.ts

@@ -0,0 +1,26 @@
+import { SchemaProperty } from '../../schemas/types/schema';
+import { SchemaValue } from '../../schemas/types/schemaValues';
+import { Require } from '../../types/utilities';
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    property: Require<SchemaProperty, 'allOf'>;
+    value: SchemaValue;
+    required: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:value": (args_0: unknown) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    property: Require<SchemaProperty, 'allOf'>;
+    value: SchemaValue;
+    required: boolean;
+}>>> & {
+    "onUpdate:value"?: ((args_0: unknown) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/src/schemas/components/SchemaFormPropertyAnyOf.vue.d.ts

@@ -0,0 +1,26 @@
+import { SchemaProperty } from '../../schemas/types/schema';
+import { SchemaValue } from '../../schemas/types/schemaValues';
+import { Require } from '../../types/utilities';
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    property: Require<SchemaProperty, 'anyOf'>;
+    value: SchemaValue;
+    required: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:value": (args_0: unknown) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    property: Require<SchemaProperty, 'anyOf'>;
+    value: SchemaValue;
+    required: boolean;
+}>>> & {
+    "onUpdate:value"?: ((args_0: unknown) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/src/schemas/components/SchemaFormPropertyBlockDocument.vue.d.ts

@@ -0,0 +1,24 @@
+import { SchemaProperty } from '../../schemas/types/schema';
+import { BlockDocumentReferenceValue } from '../../schemas/types/schemaValues';
+import { Require } from '../../types/utilities';
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    property: Require<SchemaProperty, 'block_type_slug'>;
+    value: BlockDocumentReferenceValue | null | undefined;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:value": (args_0: BlockDocumentReferenceValue | null | undefined) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    property: Require<SchemaProperty, 'block_type_slug'>;
+    value: BlockDocumentReferenceValue | null | undefined;
+}>>> & {
+    "onUpdate:value"?: ((args_0: BlockDocumentReferenceValue | null | undefined) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/src/schemas/components/SchemaFormPropertyInput.vue.d.ts

@@ -0,0 +1,23 @@
+import { SchemaProperty } from '../../schemas/types/schema';
+import { SchemaValue } from '../../schemas/types/schemaValues';
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    property: SchemaProperty;
+    value: SchemaValue;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:value": (args_0: unknown) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    property: SchemaProperty;
+    value: SchemaValue;
+}>>> & {
+    "onUpdate:value"?: ((args_0: unknown) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/src/schemas/compositions/useSchema.d.ts

@@ -0,0 +1,4 @@
+import { InjectionKey } from 'vue';
+import { Schema } from '../../schemas/types/schema';
+export declare const schemaInjectionKey: InjectionKey<Schema>;
+export declare function useSchema(): Schema;

package/dist/types/src/schemas/index.d.ts

@@ -0,0 +1,2 @@
+import SchemaForm from '../schemas/components/SchemaForm.vue';
+export { SchemaForm as SchemaFormV2 };

package/dist/types/src/schemas/types/schema.d.ts

@@ -0,0 +1,33 @@
+import { Simplify } from '../../types/utilities';
+export declare const schemaTypes: readonly ["null", "string", "boolean", "integer", "number", "array", "object"], isSchemaType: (value: unknown) => value is "string" | "number" | "boolean" | "object" | "null" | "integer" | "array";
+export type SchemaPropertyType = typeof schemaTypes[number];
+export declare function isSchemaPropertyType<T extends SchemaPropertyType | undefined>(value: unknown, type: T): value is T;
+export declare const schemaStringFormat: readonly ["date", "date-time", "regex", "password"], isSchemaStringFormat: (value: unknown) => value is "date" | "regex" | "date-time" | "password";
+export type SchemaStringFormat = typeof schemaStringFormat[number];
+export type SchemaPropertiesResponse = Record<string, SchemaPropertyResponse>;
+export type SchemaDefinitionsResponse = Record<string, SchemaPropertyResponse>;
+export type SchemaDefinition = `#/definitions/${string}`;
+export type SchemaPropertyResponse = {
+    position?: number;
+    block_type_slug?: string;
+    $ref?: SchemaDefinition;
+    anyOf?: SchemaPropertyResponse[];
+    allOf?: SchemaPropertyResponse[];
+    example?: string;
+    default?: unknown;
+    description?: string;
+    enum?: unknown[];
+    format?: SchemaStringFormat;
+    items?: SchemaPropertyResponse;
+    properties?: SchemaPropertiesResponse;
+    required?: string[];
+    title?: string;
+    type?: SchemaPropertyType;
+};
+export declare function isPropertyWith<TKey extends keyof SchemaProperty>(value: SchemaProperty, property: TKey): value is Simplify<SchemaProperty & Required<Pick<SchemaProperty, TKey>>>;
+export type SchemaResponse = SchemaPropertyResponse & {
+    definitions?: SchemaDefinitionsResponse;
+};
+export type SchemaProperties = SchemaPropertiesResponse;
+export type SchemaProperty = SchemaPropertyResponse;
+export type Schema = SchemaResponse;

package/dist/types/src/schemas/types/schemaValues.d.ts

@@ -0,0 +1,34 @@
+import { Simplify } from '../../types/utilities';
+export type SchemaValue = unknown;
+export type SchemaValues = Record<string, SchemaValue>;
+export declare const prefectKinds: readonly [null, "json", "jinja", "workspace_variable"], isPrefectKind: (value: unknown) => value is "json" | "jinja" | "workspace_variable" | null;
+export type PrefectKind = typeof prefectKinds[number];
+type BasePrefectKindValue<TKind extends PrefectKind = PrefectKind, TRest extends Record<string, unknown> = Record<string, unknown>> = {
+    __prefect_kind: TKind;
+} & TRest;
+export type PrefectKindValue = PrefectKindNull | PrefectKindJinja | PrefectKindJson | PrefectKindWorkspaceVariable;
+export declare function isPrefectKindValue<T extends PrefectKind = PrefectKind>(value: unknown, kind?: T): value is Simplify<PrefectKindValue & {
+    __prefect_kind: T;
+}>;
+export type PrefectKindNull = BasePrefectKindValue<null, {
+    value: unknown;
+}>;
+export declare function isPrefectKindNull(value: unknown): value is PrefectKindNull;
+export type PrefectKindJson = BasePrefectKindValue<'json', {
+    value: string;
+}>;
+export declare function isPrefectKindJson(value: unknown): value is PrefectKindJson;
+export type PrefectKindJinja = BasePrefectKindValue<'jinja', {
+    template: string;
+}>;
+export declare function isPrefectKindJinja(value: unknown): value is PrefectKindJinja;
+export type PrefectKindWorkspaceVariable = BasePrefectKindValue<'workspace_variable', {
+    variable_name: string;
+}>;
+export declare function isPrefectKindWorkspaceVariable(value: unknown): value is PrefectKindWorkspaceVariable;
+export type BlockDocumentReferenceValue = {
+    $ref: string;
+};
+export declare function isBlockDocumentReferenceValue(value: unknown): value is BlockDocumentReferenceValue;
+export declare function asBlockDocumentReferenceValue(value: unknown): BlockDocumentReferenceValue | null;
+export {};

package/dist/types/src/schemas/utilities/definitions.d.ts

@@ -0,0 +1,2 @@
+import { Schema, SchemaDefinition, SchemaProperty } from '../../schemas/types/schema';
+export declare function getSchemaDefinition(schema: Schema, definition: SchemaDefinition): SchemaProperty;

package/dist/types/src/schemas/utilities/properties.d.ts

@@ -0,0 +1,15 @@
+import { Schema, SchemaProperty, SchemaPropertyType } from '../../schemas/types/schema';
+import { SchemaValue } from '../../schemas/types/schemaValues';
+import { Require } from '../../types/utilities';
+import { CreateApi } from '../../utilities/api';
+export declare function getSchemaPropertyTypeLabel(type: SchemaPropertyType | undefined): string;
+export declare function getSchemaPropertyLabel(property: SchemaProperty): string;
+export declare function getSchemaPropertyAllOfDefinitions(property: Require<SchemaProperty, 'anyOf'>, schema: Schema): SchemaProperty[];
+type InitialIndexContext = {
+    property: Require<SchemaProperty, 'anyOf'>;
+    value: SchemaValue;
+    schema: Schema;
+    api: CreateApi;
+};
+export declare function getInitialIndexForSchemaPropertyAnyOfValue({ value, property, schema, api }: InitialIndexContext): Promise<number>;
+export {};

package/dist/types/src/types/utilities.d.ts

@@ -5,3 +5,6 @@ export type Require<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
 export type AnyCase<T extends string> = string extends T ? string : T extends `${infer F1}${infer F2}${infer R}` ? (`${Uppercase<F1> | Lowercase<F1>}${Uppercase<F2> | Lowercase<F2>}${AnyCase<R>}`) : T extends `${infer F}${infer R}` ? `${Uppercase<F> | Lowercase<F>}${AnyCase<R>}` : '';
 export type NumberRange<N extends number, M extends number, Result extends unknown[] = [N]> = (Result['length'] extends M ? [...Result, M] : NumberRange<N, M, [...Result, Result['length']]>);
 export type MaybeArray<T> = T | T[];
+export type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/src/utilities/types.d.ts

@@ -0,0 +1 @@
+export declare function asType<T extends () => unknown>(value: unknown, type: T): ReturnType<T> | null;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@prefecthq/prefect-ui-library",
-    "version": "2.4.30",
+    "version": "2.4.32",
     "private": false,
     "repository": {
         "type": "git",
@@ -43,7 +43,7 @@
         "@types/lodash.camelcase": "4.3.9",
         "@types/lodash.debounce": "4.0.9",
         "@types/lodash.merge": "4.6.9",
-        "@types/node": "^20.11.5",
+        "@types/node": "^20.11.10",
         "@types/prismjs": "^1.26.3",
         "@vitejs/plugin-vue": "5.0.3",
         "auto-changelog": "^2.4.0",
@@ -57,7 +57,7 @@
         "typescript": "5.3.3",
         "vite": "5.0.12",
         "vite-svg-loader": "^5.1.0",
-        "vitest": "^1.2.1",
+        "vitest": "^1.2.2",
         "vue-tsc": "1.8.27"
     },
     "peerDependencies": {