@windmill-labs/shared-utils 1.0.2 → 1.0.5

package/history.svelte.d.ts

@@ -0,0 +1,9 @@
+import { type Writable } from 'svelte/store';
+export type History<T> = Writable<{
+    history: T[];
+    index: number;
+}>;
+export declare function initHistory<T>(initial: T): History<T>;
+export declare function undo<T>(history: History<T> | undefined, now: T): T;
+export declare function redo<T>(history: History<T> | undefined): T;
+export declare function push<T>(history: History<T> | undefined, value: T, noSetIndex?: boolean): void;

package/hub.d.ts

@@ -0,0 +1,48 @@
+import type { Schema } from './common';
+import { type Flow, type Script } from './gen';
+export declare const DEFAULT_HUB_BASE_URL = "https://hub.windmill.dev";
+export declare const PRIVATE_HUB_MIN_VERSION = 10000000;
+export declare function scriptToHubUrl(content: string, summary: string, description: string, kind: Script['kind'], language: Script['language'], schema: Schema | any, lock: string | undefined, hubBaseUrl: string): URL;
+export declare const HubScript: {
+    readonly SIGNATURE_TEMPLATE: string;
+};
+export declare const HubFlow: {
+    readonly SIGNATURE_TEMPLATE: "67";
+};
+export declare function replaceScriptPlaceholderWithItsValues(id: string, content: string): string;
+export declare function loadHubFlows(): Promise<{
+    id: number;
+    flow_id: number;
+    summary: string;
+    apps: Array<(string)>;
+    approved: boolean;
+    votes: number;
+}[] | undefined>;
+export declare function loadHubApps(): Promise<{
+    id: number;
+    app_id: number;
+    summary: string;
+    apps: Array<(string)>;
+    approved: boolean;
+    votes: number;
+}[] | undefined>;
+export declare function flowToHubUrl(flow: Flow, hubBaseUrl: string): URL;
+export declare function appToHubUrl(staticApp: any, hubBaseUrl: string): URL;
+type HubPaths = {
+    gitSync: string;
+    gitSyncTest: string;
+    gitInitRepo: string;
+    slackErrorHandler: string;
+    slackRecoveryHandler: string;
+    slackSuccessHandler: string;
+    slackReport: string;
+    discordReport: string;
+    smtpReport: string;
+    teamsErrorHandler: string;
+    teamsRecoveryHandler: string;
+    teamsSuccessHandler: string;
+    emailErrorHandler: string;
+    cloneRepoToS3forGitRepoViewer: string;
+};
+export declare const hubPaths: HubPaths;
+export {};

package/jsr.json

@@ -0,0 +1,6 @@
+{
+  "name": "@windmill-labs/shared-utils",
+  "version": "1.0.5",
+  "license": "MIT",
+  "exports": "./mod.ts"
+}

package/lib.d.ts

@@ -1,3 +1,4 @@
-import { App } from '../types';
-import { Policy } from '../../../../../../src/lib/gen';
-export declare function updatePolicy(app: App, currentPolicy: Policy | undefined): Promise<Policy>;
+export { updatePolicy } from './components/apps/editor/appPolicy';
+export { genWmillTs } from './components/raw_apps/utils';
+export { updateRawAppPolicy } from './components/raw_apps/rawAppPolicy';
+export declare function capitalize(word: string): string;

package/lib.es.js

@@ -592,8 +592,7 @@ var init_whatwgEncodingApi = __esmMin((() => {})), dist_es_exports = /* @__PURE_
 	}
 })), require_build = /* @__PURE__ */ __commonJSMin(((c) => {
 	Object.defineProperty(c, "__esModule", { value: !0 }), (init_tslib_es6(), __toCommonJS(tslib_es6_exports)).__exportStar(require_jsSha256(), c);
-}));
-require_build();
+})), import_build$1 = /* @__PURE__ */ __toESM(require_build());
 function wrapDucklakeQuery(c, L) {
 	let R = `ATTACH 'ducklake://${L}' AS dl;USE dl;\n`;
 	return c.replace(/^(--.*\n)*/, (c) => c + R);
@@ -1232,6 +1231,15 @@ function computeS3ImageViewerPolicy(c) {
 function collectStaticFields(c) {
 	return Object.fromEntries(Object.entries(c ?? {}).filter(([c, L]) => L.type == "static").map(([c, L]) => [c, L.value]));
 }
+async function hash(c) {
+	try {
+		let L = new TextEncoder().encode(c), R = await crypto.subtle.digest("SHA-256", L);
+		return Array.from(new Uint8Array(R)).map((c) => c.toString(16).padStart(2, "0")).join("");
+	} catch {
+		let L = new import_build$1.Sha256();
+		return L.update(c ?? ""), Array.from(await L.digest()).map((c) => c.toString(16).padStart(2, "0")).join("");
+	}
+}
 var import_build = /* @__PURE__ */ __toESM(require_build());
 async function updatePolicy(c, L) {
 	let R = allItems(c.grid, c.subgrids), z = await Promise.all(R.flatMap((L) => {
@@ -1286,9 +1294,9 @@ async function updatePolicy(c, L) {
 			z.push(...c);
 		}
 		return z.filter((c) => c.input).map(async (L) => {
-			if (L.input?.type == "runnable") return await processRunnable(L.id, L.input.runnable, L.input.fields, c);
+			if (L.input?.type == "runnable") return await processRunnable$1(L.id, L.input.runnable, L.input.fields, c);
 		});
-	}).concat(Object.values(c.hiddenInlineScripts ?? {}).map(async (L, R) => await processRunnable("bg_" + R, L, L.fields, c)))), B = Object.fromEntries(z.filter(Boolean)), V = R.filter((c) => c.data.type === "s3fileinputcomponent").map((L) => {
+	}).concat(Object.values(c.hiddenInlineScripts ?? {}).map(async (L, R) => await processRunnable$1("bg_" + R, L, L.fields, c)))), B = Object.fromEntries(z.filter(Boolean)), V = R.filter((c) => c.data.type === "s3fileinputcomponent").map((L) => {
 		let R = L.data.configuration;
 		return computeS3FileInputPolicy(R?.type?.configuration?.s3, c);
 	}).filter(Boolean);
@@ -1310,10 +1318,10 @@ async function updatePolicy(c, L) {
 		triggerables_v2: B
 	};
 }
-async function processRunnable(c, L, R, z) {
+async function processRunnable$1(c, L, R, z) {
 	let B = collectStaticFields(R), V = collectOneOfFields(R, z), H = Object.entries(R).map(([c, L]) => L.allowUserResources ? c : void 0).filter(Boolean);
 	if (L?.type == "runnableByName") {
-		let R = await hash(L.inlineScript?.content);
+		let R = await hash$1(L.inlineScript?.content);
 		return console.debug("hex", R, c), [`${c}:rawscript/${R}`, {
 			static_inputs: B,
 			one_of_inputs: V,
@@ -1325,7 +1333,7 @@ async function processRunnable(c, L, R, z) {
 		allow_user_resources: H
 	}];
 }
-async function hash(c) {
+async function hash$1(c) {
 	try {
 		let L = new TextEncoder().encode(c), R = await crypto.subtle.digest("SHA-256", L);
 		return Array.from(new Uint8Array(R)).map((c) => c.toString(16).padStart(2, "0")).join("");
@@ -1334,4 +1342,93 @@ async function hash(c) {
 		return L.update(c ?? ""), Array.from(await L.digest()).map((c) => c.toString(16).padStart(2, "0")).join("");
 	}
 }
-export { updatePolicy };
+function schemaToTsType(c) {
+	let L = c.properties, R = c.required;
+	return !c || !L ? "any" : `{ ${Object.keys(L).map((c) => {
+		let z = L[c], B = `${c}${R?.includes(c) ? "" : "?"}`, V = "any";
+		return z.type === "string" ? V = "string" : z.type === "number" || z.type === "integer" ? V = "number" : z.type === "boolean" ? V = "boolean" : z.type === "array" ? (V = z.items?.type ?? "any", V === "integer" && (V = "number"), V = `${V}[]`) : z.type === "object" && z.properties && (V = schemaToTsType(z)), `${B}: ${V}`;
+	}).join("; ")} }`;
+}
+function removeStaticFields(c, L) {
+	let R = Object.keys(L).filter((c) => L[c].type == "static");
+	return {
+		...c,
+		properties: { ...Object.fromEntries(Object.entries(c.properties ?? {}).filter(([c]) => !R.includes(c))) }
+	};
+}
+function hiddenRunnableToTsType(c) {
+	return c?.type == "runnableByName" ? c?.inlineScript?.schema ? schemaToTsType(removeStaticFields(c?.inlineScript?.schema, c?.fields ?? {})) : "{}" : c?.type == "runnableByPath" ? schemaToTsType(removeStaticFields(c?.schema, c?.fields ?? {})) : "{}";
+}
+function genWmillTs(c) {
+	return `// THIS FILE IS READ-ONLY
+// AND GENERATED AUTOMATICALLY FROM YOUR RUNNABLES
+	
+${Object.entries(c).map(([c, L]) => `export type RunBg${capitalize(c)} = ${hiddenRunnableToTsType(L)}\n`).join("\n")}
+
+export const runBg = {
+${Object.keys(c).map((c) => `  ${c}: null as unknown as (data: RunBg${capitalize(c)}) => Promise<any>`).join(",\n")}
+}
+	
+export const runBgAsync = {
+${Object.keys(c).map((c) => `  ${c}: null as unknown as (data: RunBg${capitalize(c)}) => Promise<string>`).join(",\n")}
+}
+	
+
+export type Job = {
+	type: 'QueuedJob' | 'CompletedJob'
+	id: string
+	created_at: number
+	started_at: number | undefined
+	duration_ms: number
+	success: boolean
+	args: any
+	result: any
+}
+
+/**
+* Execute a job and wait for it to complete and return the completed job
+* @param id
+*/
+// @ts-ignore
+export function waitJob(id: string): Promise<Job> {
+	// implementation passed when bundling/deploying
+	return null as unknown as Promise<Job>
+}
+
+/**
+* Get a job by id and return immediately with the current state of the job
+* @param id
+*/
+// @ts-ignore
+export function getJob(id: string): Promise<Job> {
+	// implementation passed when bundling/deploying
+	return null as unknown as Promise<Job>
+}
+`;
+}
+async function updateRawAppPolicy(c, L) {
+	let R = Object.fromEntries(await Promise.all(Object.values(c).map(async (c) => await processRunnable(c?.name ?? "", c, c?.fields ?? {}))));
+	return {
+		...L,
+		triggerables_v2: R
+	};
+}
+async function processRunnable(c, L, R) {
+	let z = collectStaticFields(R), B = Object.entries(R).map(([c, L]) => L.allowUserResources ? c : void 0).filter(Boolean);
+	if (L?.type == "runnableByName") {
+		let R = await hash(L.inlineScript?.content);
+		return console.log("hex", R, c), [`${c}:rawscript/${R}`, {
+			static_inputs: z,
+			one_of_inputs: {},
+			allow_user_resources: B
+		}];
+	} else if (L?.type == "runnableByPath") return [`${c}:${L.runType === "hubscript" ? "script" : L.runType}/${L.path}`, {
+		static_inputs: z,
+		one_of_inputs: {},
+		allow_user_resources: B
+	}];
+}
+function capitalize(c) {
+	return c ? c.charAt(0).toUpperCase() + c.slice(1) : "";
+}
+export { capitalize, genWmillTs, updatePolicy, updateRawAppPolicy };

package/package.json

@@ -1,12 +1,12 @@
 {
-	"name": "@windmill-labs/shared-utils",
-	"version": "1.0.2",
-	"type": "module",
-	"private": false,
-	"main": "./lib.es.js",
-	"module": "./lib.es.js",
-	"exports": {
-		".": "./lib.es.js"
-	},
-	"types": "./lib.d.ts"
-}
+  "name": "@windmill-labs/shared-utils",
+  "version": "1.0.5",
+  "type": "module",
+  "private": false,
+  "main": "./lib.es.js",
+  "module": "./lib.es.js",
+  "exports": {
+    ".": "./lib.es.js"
+  },
+  "types": "./lib.d.ts"
+}

package/schema.d.ts

@@ -0,0 +1,3 @@
+import type { Schema, SchemaProperty } from './common';
+export declare function schemaToTsType(schema: Schema | SchemaProperty): string;
+export declare function schemaToObject(schema: Schema, args: Record<string, any>): Object;

package/stores.d.ts

@@ -0,0 +1,96 @@
+import { type Readable } from 'svelte/store';
+import type { IntrospectionQuery } from 'graphql';
+import { type OperatorSettings, type TokenResponse, type UserWorkspaceList, type WorkspaceDefaultScripts } from './gen';
+import { type StateStore } from './utils';
+export interface UserExt {
+    email: string;
+    name?: string;
+    username: string;
+    is_admin: boolean;
+    is_super_admin: boolean;
+    operator: boolean;
+    created_at: string;
+    groups: string[];
+    pgroups: string[];
+    folders: string[];
+    folders_owners: string[];
+}
+export interface UserWorkspace {
+    id: string;
+    name: string;
+    username: string;
+    color?: string;
+    operator_settings?: OperatorSettings;
+    parent_workspace_id?: string | null;
+    disabled: boolean;
+}
+export declare function getWorkspaceFromStorage(): string | undefined;
+export declare function clearWorkspaceFromStorage(): void;
+export declare const tutorialsToDo: import("svelte/store").Writable<number[]>;
+export declare const globalEmailInvite: import("svelte/store").Writable<string>;
+export declare const awarenessStore: import("svelte/store").Writable<Record<string, string>>;
+export declare const enterpriseLicense: import("svelte/store").Writable<string | undefined>;
+export declare const whitelabelNameStore: Readable<string | undefined>;
+export declare const workerTags: import("svelte/store").Writable<string[] | undefined>;
+export declare const usageStore: import("svelte/store").Writable<number>;
+export declare const workspaceUsageStore: import("svelte/store").Writable<number>;
+export declare const initialArgsStore: import("svelte/store").Writable<any>;
+export declare const oauthStore: import("svelte/store").Writable<TokenResponse | undefined>;
+export declare const userStore: import("svelte/store").Writable<UserExt | undefined>;
+export declare const workspaceStore: import("svelte/store").Writable<string | undefined>;
+export declare const defaultScripts: import("svelte/store").Writable<WorkspaceDefaultScripts | undefined>;
+export declare const dbClockDrift: import("svelte/store").Writable<number | undefined>;
+export declare const isPremiumStore: import("svelte/store").Writable<boolean>;
+export declare const starStore: import("svelte/store").Writable<number>;
+export declare const usersWorkspaceStore: import("svelte/store").Writable<UserWorkspaceList | undefined>;
+export declare const superadmin: import("svelte/store").Writable<string | false | undefined>;
+export declare const devopsRole: import("svelte/store").Writable<string | false | undefined>;
+export declare const lspTokenStore: import("svelte/store").Writable<string | undefined>;
+export declare const hubBaseUrlStore: import("svelte/store").Writable<string>;
+export declare const userWorkspaces: Readable<Array<UserWorkspace>>;
+export declare const codeCompletionLoading: import("svelte/store").Writable<boolean>;
+export declare const metadataCompletionEnabled: import("svelte/store").Writable<boolean>;
+export declare const stepInputCompletionEnabled: import("svelte/store").Writable<boolean>;
+export declare const FORMAT_ON_SAVE_SETTING_NAME = "formatOnSave";
+export declare const VIM_MODE_SETTING_NAME = "vimMode";
+export declare const RELATIVE_LINE_NUMBERS_SETTING_NAME = "relativeLineNumbers";
+export declare const CODE_COMPLETION_SETTING_NAME = "codeCompletionSessionEnabled";
+export declare const COPILOT_SESSION_MODEL_SETTING_NAME = "copilotSessionModel";
+export declare const COPILOT_SESSION_PROVIDER_SETTING_NAME = "copilotSessionProvider";
+export declare const formatOnSave: import("svelte/store").Writable<boolean>;
+export declare const vimMode: import("svelte/store").Writable<boolean>;
+export declare const relativeLineNumbers: import("svelte/store").Writable<boolean>;
+export declare const codeCompletionSessionEnabled: import("svelte/store").Writable<boolean>;
+export declare const usedTriggerKinds: import("svelte/store").Writable<string[]>;
+type SQLBaseSchema = {
+    [schemaKey: string]: {
+        [tableKey: string]: {
+            [columnKey: string]: {
+                type: string;
+                default: string;
+                required: boolean;
+            };
+        };
+    };
+};
+export declare const SQLSchemaLanguages: readonly ["mysql", "bigquery", "postgresql", "snowflake", "mssql", "oracledb"];
+export interface SQLSchema {
+    lang: (typeof SQLSchemaLanguages)[number] | 'ducklake';
+    schema: SQLBaseSchema;
+    publicOnly: boolean | undefined;
+    stringified: string;
+}
+export interface GraphqlSchema {
+    lang: 'graphql';
+    schema: IntrospectionQuery;
+    stringified: string;
+}
+export type DBSchema = SQLSchema | GraphqlSchema;
+export type DBSchemas = Partial<Record<string, DBSchema>>;
+export declare const dbSchemas: import("svelte/store").Writable<Partial<Record<string, DBSchema>>>;
+export declare const instanceSettingsSelectedTab: import("svelte/store").Writable<string>;
+export declare const isCriticalAlertsUIOpen: import("svelte/store").Writable<boolean>;
+export declare const workspaceColor: Readable<string | null | undefined>;
+export declare const isCurrentlyInTutorial: StateStore<boolean>;
+export declare function getFlatTableNamesFromSchema(dbSchema: DBSchema | undefined): string[];
+export {};

package/svelte5Utils.svelte.d.ts

@@ -0,0 +1,49 @@
+import type { StateStore } from './utils';
+export declare function withProps<Component, Props>(component: Component, props: Props): {
+    component: Component;
+    props: Props;
+};
+export declare function createState<T>(initialValue: T): T;
+export declare function stateSnapshot<T>(state: T): $state.Snapshot<T>;
+export declare function refreshStateStore<T>(store: StateStore<T>): void;
+export type UsePromiseResult<T> = ({
+    status: 'loading';
+    value?: undefined;
+    error?: undefined;
+} | {
+    status: 'error';
+    error: any;
+    value?: undefined;
+} | {
+    status: 'ok';
+    value: T;
+    error?: undefined;
+} | {
+    status: 'idle';
+    value?: undefined;
+    error?: undefined;
+}) & {
+    refresh: () => void;
+    clear: () => void;
+};
+export type UsePromiseOptions = {
+    loadInit?: boolean;
+    clearValueOnRefresh?: boolean;
+};
+export declare function usePromise<T>(createPromise: () => Promise<T>, { loadInit, clearValueOnRefresh }?: UsePromiseOptions): UsePromiseResult<T>;
+/**
+ * Generic change tracker class that monitors changes in state using deep equality comparison
+ * and provides a counter to trigger Svelte 5 reactivity. Similar to the pattern used in
+ * FlowGraphV2.svelte's onModulesChange2 function.
+ */
+export declare class ChangeTracker<T> {
+    #private;
+    counter: number;
+    constructor(initialValue?: T);
+    /**
+     * Check if the value has changed and update the counter to trigger reactivity
+     * @param value - The current value to check for changes
+     * @returns true if the value changed, false otherwise
+     */
+    track(value: T): boolean;
+}

package/toast.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentProps } from 'svelte';
+import type { Button } from './components/common';
+export type ToastAction = {
+    label: string;
+    callback: () => void;
+    buttonType?: ComponentProps<typeof Button>['variant'];
+};
+export declare function sendUserToast(message: string, error?: boolean, actions?: ToastAction[], errorMessage?: string | undefined, duration?: number): void;