likec4 1.48.0 → 1.49.0

package/react/package.json

@@ -1,7 +1,4 @@
 {
-  "name": "@likec4/react",
-  "type": "module",
-  "sideEffects": false,
-  "types": "./index.d.ts",
-  "module": "./index.js"
+  "types": "index.d.mts",
+  "module": "index.mjs"
 }

package/vite-plugin-modules.d.ts

@@ -28,7 +28,7 @@ declare module 'likec4:icons' {
   }
 
   export type ElementIconRenderer = (props: ElementIconRendererProps) => ReactNode
-  export const ProjectIcons: (props: ElementIconRendererProps & { projectId: string }) => ReactNode
+  export function getProjectIcons(projectId: string): ElementIconRenderer
 }
 
 declare module 'likec4:model' {
@@ -54,8 +54,8 @@ declare module 'likec4:single-project' {
     types,
     UnknownLayouted,
   } from 'likec4/model'
-  import type { ElementIconRenderer } from 'likec4:icons'
   import type { Atom } from 'likec4/vite-plugin/internal'
+  import type { ElementIconRenderer } from 'likec4:icons'
 
   export const $likec4data: Atom<LayoutedLikeC4ModelData>
   export const $likec4model: Atom<LikeC4Model<UnknownLayouted>>
@@ -117,7 +117,7 @@ declare module 'likec4:model/*' {
   import type { Atom } from 'likec4:model'
 
   // This will be used later for augmenting the types
-  declare interface Types extends UnknownLayouted {
+  interface Types extends UnknownLayouted {
   }
 
   export type LikeC4ViewId = aux.ViewId<Types>
@@ -165,7 +165,7 @@ declare module 'likec4:rpc' {
   import type { LikeC4VitePluginRpc } from 'likec4/vite-plugin/internal'
 
   export type { LikeC4VitePluginRpc }
-  export declare const likec4rpc: LikeC4VitePluginRpc
+  export const likec4rpc: LikeC4VitePluginRpc
 
-  export declare const isRpcAvailable: boolean
+  export const isRpcAvailable: boolean
 }

package/dist/_chunks/LikeC4.d.mts

@@ -1,121 +0,0 @@
-import { i as ProjectsManager, r as LikeC4Views, t as LikeC4LanguageServices } from "./index2.mjs";
-import { a as createLanguageServices, o as Logger } from "./module.mjs";
-import { M as index_d_exports, v as LikeC4Model } from "./index3.mjs";
-import { NonEmptyArray, ProjectId } from "@likec4/core";
-
-//#region src/LikeC4.d.ts
-type LikeC4Langium = ReturnType<typeof createLanguageServices>;
-type LikeC4Options = {
-  /**
-   * By default, if LikeC4 model is invalid, errors are printed to the console.
-   * Disable this behavior by setting this option to false.
-   *
-   * @default true
-   */
-  printErrors?: boolean;
-  /**
-   * If true, initialization will return rejected promise with the LikeC4 instance.
-   * Use `likec4.getErrors()` to get the errors.
-   * @default false
-   */
-  throwIfInvalid?: boolean;
-  /**
-   * Logger to use for the language service.
-   * false - no output
-   * @default 'default'
-   */
-  logger?: Logger | 'vite' | 'default' | false;
-  /**
-   * Whether to use the `dot` binary for layouting or the WebAssembly version.
-   * @default 'wasm'
-   */
-  graphviz?: 'wasm' | 'binary';
-  /**
-   * Whether to start MCP server
-   * @default false
-   */
-  mcp?: false | 'stdio' | {
-    port: number;
-  };
-  /**
-   * Whether to watch for changes in the workspace.
-   * @default false
-   */
-  watch?: boolean;
-};
-declare class LikeC4 {
-  readonly workspace: string;
-  readonly langium: LikeC4Langium;
-  static fromSource(likec4SourceCode: string, opts?: LikeC4Options): Promise<LikeC4>;
-  /**
-   * Prevents multiple instances of LikeC4 for the same workspace
-   */
-  private static likec4Instances;
-  /**
-   * Initializes a LikeC4 instance from the specified workspace path.
-   * By default in current folder
-   */
-  static fromWorkspace(path?: string, opts?: LikeC4Options): Promise<LikeC4>;
-  private logger;
-  private constructor();
-  get languageServices(): LikeC4LanguageServices;
-  get projectsManager(): ProjectsManager;
-  get viewsService(): LikeC4Views;
-  private get LangiumDocuments();
-  ensureSingleProject(): void;
-  /**
-   * Diagram is a computed view, layouted using Graphviz
-   * If diagram has manual layout, it will be used.
-   * Used in React components
-   */
-  diagrams(projectId?: ProjectId | undefined): Promise<index_d_exports.DiagramView[]>;
-  /**
-   * Builds LikeC4Model from all documents
-   * Only computes view predicates {@link ComputedView} - i.e. no layout
-   * Not ready for rendering, but enough to traverse
-   *
-   * Sync version does not read manual layouts
-   * Use {@link computedModel} for a version that includes manual layouts
-   */
-  syncComputedModel(project?: ProjectId | undefined): LikeC4Model.Computed;
-  /**
-   * Builds LikeC4Model from all documents
-   * Only computes view predicates {@link ComputedView} - i.e. no layout
-   * Not ready for rendering, but enough to traverse
-   */
-  computedModel(project?: ProjectId | undefined): Promise<LikeC4Model.Computed>;
-  projects(): NonEmptyArray<ProjectId>;
-  /**
-   * Same as {@link computedModel()}, but also applies layout
-   * Ready for rendering
-   */
-  layoutedModel(project?: ProjectId | undefined): Promise<LikeC4Model.Layouted>;
-  getErrors(): Array<{
-    message: string;
-    line: number;
-    range: {
-      start: {
-        line: number;
-        character: number;
-      };
-      end: {
-        line: number;
-        character: number;
-      };
-    };
-    sourceFsPath: string;
-  }>;
-  hasErrors(): boolean;
-  /**
-   * @returns true if there are errors
-   */
-  printErrors(): boolean;
-  /**
-   * @returns a function to dispose the listener
-   */
-  onModelUpdate(listener: () => void): () => void;
-  dispose(): Promise<void>;
-  [Symbol.asyncDispose](): Promise<void>;
-}
-//#endregion
-export { LikeC4Options as n, LikeC4 as t };

package/dist/_chunks/LikeC4.mjs

@@ -1,202 +0,0 @@
-import { t as defu } from "./libs/defu.mjs";
-import { $ as init_main, G as DiagnosticSeverity, L as UriUtils, R as URI } from "./libs/langium.mjs";
-import { h as t, l as e } from "./libs/remeda.mjs";
-import { t as u } from "./libs/tinyrainbow.mjs";
-import { n as createLanguageServices } from "./module.mjs";
-import { existsSync } from "node:fs";
-import { basename, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-
-//#region src/LikeC4.ts
-init_main();
-const validationErrorsToError = (likec4) => /* @__PURE__ */ new Error(`Invalid model:\n${likec4.getErrors().map((e) => `  ${e.sourceFsPath}:${e.line} ${e.message.slice(0, 200)}`).join("\n")}`);
-var LikeC4 = class LikeC4 {
-	static async fromSource(likec4SourceCode, opts) {
-		const langium = createLanguageServices(defu(opts, {
-			useFileSystem: false,
-			watch: false,
-			logger: false,
-			graphviz: "wasm",
-			mcp: false
-		}));
-		const workspaceUri = URI.from({
-			scheme: "virtual",
-			path: "/workspace"
-		});
-		const uri = UriUtils.joinPath(workspaceUri, "source.likec4");
-		const doc = langium.shared.workspace.LangiumDocuments.createDocument(uri, likec4SourceCode);
-		await langium.cli.Workspace.initWorkspace({
-			uri: workspaceUri.toString(),
-			name: "virtual"
-		});
-		await langium.shared.workspace.DocumentBuilder.build([doc], { validation: true });
-		const likec4 = new LikeC4(workspaceUri.path, langium);
-		if (opts?.throwIfInvalid === true && likec4.hasErrors()) {
-			await likec4.dispose();
-			return Promise.reject(validationErrorsToError(likec4));
-		}
-		if (opts?.printErrors !== false && likec4.hasErrors()) likec4.printErrors();
-		return likec4;
-	}
-	/**
-	* Prevents multiple instances of LikeC4 for the same workspace
-	*/
-	static likec4Instances = /* @__PURE__ */ new Map();
-	/**
-	* Initializes a LikeC4 instance from the specified workspace path.
-	* By default in current folder
-	*/
-	static async fromWorkspace(path = ".", opts) {
-		const workspace = resolve(path);
-		if (!existsSync(workspace)) throw new Error(`Workspace not found: ${workspace}`);
-		let likec4 = LikeC4.likec4Instances.get(workspace);
-		if (!likec4) {
-			const langium = createLanguageServices(defu(opts, {
-				useFileSystem: true,
-				watch: false,
-				logger: "default",
-				graphviz: "wasm",
-				mcp: false
-			}));
-			likec4 = new LikeC4(workspace, langium);
-			LikeC4.likec4Instances.set(workspace, likec4);
-			await langium.cli.Workspace.initWorkspace({
-				uri: pathToFileURL(workspace).toString(),
-				name: basename(workspace)
-			});
-			if (opts?.printErrors !== false && likec4.hasErrors()) likec4.printErrors();
-		}
-		if (opts?.throwIfInvalid === true && likec4.hasErrors()) {
-			await likec4.dispose();
-			return Promise.reject(validationErrorsToError(likec4));
-		}
-		return likec4;
-	}
-	logger;
-	constructor(workspace, langium) {
-		this.workspace = workspace;
-		this.langium = langium;
-		this.logger = langium.logger;
-	}
-	get languageServices() {
-		return this.langium.likec4.LanguageServices;
-	}
-	get projectsManager() {
-		return this.langium.shared.workspace.ProjectsManager;
-	}
-	get viewsService() {
-		return this.langium.likec4.Views;
-	}
-	get LangiumDocuments() {
-		return this.langium.shared.workspace.LangiumDocuments;
-	}
-	ensureSingleProject() {
-		const projects = this.langium.likec4.LanguageServices.projects();
-		if (projects.length > 1) {
-			this.logger.error(`Multiple projects found:
-${projects.map((p) => `  - ${p.folder.fsPath}`).join("\n")}
-
-${u.red("Please specify a project folder")}
-`);
-			throw new Error(`Multiple projects found`);
-		}
-	}
-	/**
-	* Diagram is a computed view, layouted using Graphviz
-	* If diagram has manual layout, it will be used.
-	* Used in React components
-	*/
-	async diagrams(projectId) {
-		return await this.langium.likec4.Views.diagrams(projectId);
-	}
-	/**
-	* Builds LikeC4Model from all documents
-	* Only computes view predicates {@link ComputedView} - i.e. no layout
-	* Not ready for rendering, but enough to traverse
-	*
-	* Sync version does not read manual layouts
-	* Use {@link computedModel} for a version that includes manual layouts
-	*/
-	syncComputedModel(project) {
-		const projectId = this.langium.shared.workspace.ProjectsManager.ensureProjectId(project);
-		return this.langium.likec4.ModelBuilder.unsafeSyncComputeModel(projectId);
-	}
-	/**
-	* Builds LikeC4Model from all documents
-	* Only computes view predicates {@link ComputedView} - i.e. no layout
-	* Not ready for rendering, but enough to traverse
-	*/
-	async computedModel(project) {
-		return await this.langium.likec4.ModelBuilder.computeModel(project);
-	}
-	projects() {
-		return t(this.langium.likec4.LanguageServices.projects(), e("id"));
-	}
-	/**
-	* Same as {@link computedModel()}, but also applies layout
-	* Ready for rendering
-	*/
-	async layoutedModel(project) {
-		return await this.langium.likec4.LanguageServices.layoutedModel(project);
-	}
-	getErrors() {
-		return this.LangiumDocuments.all.toArray().flatMap((doc) => {
-			return (doc.diagnostics ?? []).filter((d) => d.severity === DiagnosticSeverity.Error).map(({ message, range }) => ({
-				message,
-				line: range.start.line,
-				range,
-				sourceFsPath: doc.uri.fsPath
-			}));
-		});
-	}
-	hasErrors() {
-		return this.LangiumDocuments.all.some((doc) => {
-			return doc.diagnostics?.some((d) => d.severity === DiagnosticSeverity.Error) ?? false;
-		});
-	}
-	/**
-	* @returns true if there are errors
-	*/
-	printErrors() {
-		let hasErrors = false;
-		for (const doc of this.LangiumDocuments.all) {
-			const errors = doc.diagnostics?.filter((e) => e.severity === 1);
-			if (errors && errors.length > 0) {
-				hasErrors = true;
-				const messages = errors.flatMap((validationError) => {
-					const line = validationError.range.start.line;
-					const messages = validationError.message.split("\n");
-					if (messages.length > 10) {
-						messages.length = 10;
-						messages.push("...");
-					}
-					return messages.map((message, i) => {
-						if (i === 0) return "    " + u.dim(`Line ${line}: `) + u.red(message);
-						return " ".repeat(10) + u.red(message);
-					});
-				}).join("\n");
-				this.logger.error(`Invalid ${doc.uri.fsPath}\n${messages}`);
-			}
-		}
-		return hasErrors;
-	}
-	/**
-	* @returns a function to dispose the listener
-	*/
-	onModelUpdate(listener) {
-		const sib = this.langium.likec4.ModelBuilder.onModelParsed(() => listener());
-		return () => {
-			sib.dispose();
-		};
-	}
-	async dispose() {
-		await this.langium.likec4.LanguageServices.dispose();
-		for (const [path, likec4] of LikeC4.likec4Instances) if (likec4 === this) LikeC4.likec4Instances.delete(path);
-	}
-	async [Symbol.asyncDispose]() {
-		await this.dispose();
-	}
-};
-
-//#endregion
-export { LikeC4 as t };

package/dist/_chunks/config-app.prod.d.mts

@@ -1,18 +0,0 @@
-import { s as ViteLogger } from "./module.mjs";
-import { t as LikeC4 } from "./LikeC4.mjs";
-import "vite";
-
-//#region src/vite/config-app.prod.d.ts
-type LikeC4ViteConfig = {
-  customLogger?: ViteLogger;
-  languageServices: LikeC4;
-  outputDir?: string | undefined;
-  base?: string | undefined;
-  title?: string | undefined;
-  webcomponentPrefix?: string | undefined;
-  useHashHistory?: boolean | undefined;
-  likec4AssetsDir: string;
-  outputSingleFile?: boolean | undefined;
-};
-//#endregion
-export { LikeC4ViteConfig as t };

package/dist/_chunks/config-app.prod.mjs

@@ -1,188 +0,0 @@
-import { H as r } from "./libs/remeda.mjs";
-import { t as u } from "./libs/tinyrainbow.mjs";
-import { d as logger, i as createLikeC4Logger } from "./module.mjs";
-import { c as withLeadingSlash, r as hasProtocol, u as withTrailingSlash } from "./libs/ufo.mjs";
-import { t as packageUpSync } from "./libs/package-up.mjs";
-import { t as LikeC4VitePlugin } from "./plugin.mjs";
-import { existsSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { mkdtemp, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import react from "@vitejs/plugin-react";
-import { viteSingleFile } from "vite-plugin-singlefile";
-
-//#region src/vite/utils.ts
-const viteLogger = createLikeC4Logger("vite");
-const _dirname = dirname(fileURLToPath(import.meta.url));
-const banner = `
-/* prettier-ignore-start */
-/* eslint-disable */
-
-/******************************************************************************
- * This file was generated
- * DO NOT EDIT MANUALLY!
- ******************************************************************************/
-
-`.trimStart();
-const footer = `
-
-/* prettier-ignore-end */
-`;
-const JsBanners = {
-	banner,
-	footer
-};
-function findPkgRoot() {
-	const pkgRoot = packageUpSync({ cwd: _dirname });
-	if (!pkgRoot) throw new Error(`likec4 package folder not found`);
-	return dirname(pkgRoot);
-}
-function viteAppRoot() {
-	const roots = [
-		resolve(findPkgRoot(), "__app__"),
-		resolve(_dirname, "../__app__"),
-		resolve(_dirname, "../../__app__"),
-		resolve(_dirname, "../../dist/__app__")
-	];
-	const root = r(roots, existsSync);
-	if (!root) {
-		logger.error(`likec4 app root does not exist, tried:\n${roots.join("\n")}`);
-		throw new Error(`likec4 app root does not exist`);
-	}
-	return root;
-}
-async function mkTempPublicDir() {
-	const publicDir = await mkdtemp(join(tmpdir(), ".likec4-public-"));
-	await writeFile(join(publicDir, "likec4-views.js"), "// generated by likec4\n");
-	return publicDir;
-}
-/**
-* Adjust chunk size warning limit (in kB).
-*/
-const chunkSizeWarningLimit = 1e4;
-
-//#endregion
-//#region src/vite/aliases.prod.ts
-function viteAliases() {
-	const pkg = findPkgRoot();
-	return {
-		"likec4/icons": "@likec4/icons",
-		"likec4/react": resolve(pkg, "react/index.js"),
-		"likec4/model": resolve(pkg, "dist/model/index.mjs"),
-		"likec4/vite-plugin/internal": resolve(pkg, "dist/vite-plugin/internal.mjs")
-	};
-}
-
-//#endregion
-//#region src/vite/config-app.prod.ts
-const viteConfig = async ({ languageServices, likec4AssetsDir, ...cfg }) => {
-	const customLogger = cfg.customLogger ?? viteLogger;
-	const root = viteAppRoot();
-	customLogger.info(`${u.cyan("likec4 app root")} ${u.dim(root)}`);
-	const outDir = cfg.outputDir ?? resolve(languageServices.workspace, "dist");
-	customLogger.info(u.cyan("outDir") + " " + u.dim(outDir));
-	let base = "/";
-	if (cfg.base) {
-		base = withTrailingSlash(cfg.base);
-		if (!hasProtocol(base) && base !== "./") base = withLeadingSlash(base);
-	}
-	if (base !== "/") customLogger.info(`${u.green("app base url")} ${u.dim(base)}`);
-	const webcomponentPrefix = cfg.webcomponentPrefix ?? "likec4";
-	const title = cfg.title ?? "LikeC4";
-	const isSingleFile = cfg.outputSingleFile ?? false;
-	return {
-		isDev: false,
-		likec4AssetsDir,
-		webcomponentPrefix,
-		title,
-		root,
-		languageServices,
-		clearScreen: false,
-		base,
-		resolve: {
-			conditions: ["production"],
-			dedupe: [
-				"react",
-				"react-dom",
-				"react/jsx-runtime",
-				"react/jsx-dev-runtime",
-				"react-dom/client"
-			],
-			alias: {
-				...viteAliases(),
-				"likec4/previews": likec4AssetsDir
-			}
-		},
-		configFile: false,
-		mode: "production",
-		optimizeDeps: {
-			include: [
-				"react",
-				"react-dom",
-				"react/jsx-runtime",
-				"react/jsx-dev-runtime",
-				"react-dom/client",
-				"@likec4/core/types",
-				"@likec4/core/model",
-				"@likec4/core/styles",
-				"@likec4/core/utils",
-				"@likec4/core",
-				"likec4/model",
-				"likec4/react",
-				"likec4/vite-plugin/internal"
-			],
-			noDiscovery: true
-		},
-		esbuild: { tsconfigRaw: { compilerOptions: {
-			target: "ESNext",
-			jsx: "react-jsx"
-		} } },
-		define: {
-			WEBCOMPONENT_PREFIX: JSON.stringify(webcomponentPrefix),
-			PAGE_TITLE: JSON.stringify(title),
-			__USE_HASH_HISTORY__: cfg?.useHashHistory === true ? "true" : "false",
-			"process.env.NODE_ENV": "\"production\""
-		},
-		build: {
-			outDir,
-			emptyOutDir: false,
-			sourcemap: false,
-			cssMinify: false,
-			minify: true,
-			copyPublicDir: true,
-			chunkSizeWarningLimit,
-			assetsInlineLimit: 1e5,
-			rollupOptions: {
-				treeshake: { preset: "recommended" },
-				...!isSingleFile && {
-					input: [
-						resolve(root, "index.html"),
-						resolve(root, "src", "main.js"),
-						resolve(root, "src", "fonts.css"),
-						resolve(root, "src", "style.css")
-					],
-					output: { manualChunks: (id) => {
-						if (id.endsWith(".css") || id.endsWith(".html") || id.includes("likec4/icons")) return;
-						if (id.includes("__app__")) {
-							let match = id.match(/__app__\/src\/([\w]+)\.js/)?.[1];
-							if (match) return match[1];
-							return;
-						}
-						if (id.includes("node_modules/likec4") || id.includes("node_modules/@likec4")) return "likec4";
-						if (id.includes("node_modules")) return "vendors";
-					} }
-				}
-			}
-		},
-		customLogger,
-		plugins: [
-			react(),
-			LikeC4VitePlugin({ languageServices: languageServices.languageServices }),
-			isSingleFile ? viteSingleFile() : void 0
-		]
-	};
-};
-
-//#endregion
-export { mkTempPublicDir as a, chunkSizeWarningLimit as i, viteAliases as n, viteAppRoot as o, JsBanners as r, viteConfig as t };

package/dist/_chunks/config-webcomponent.prod.mjs

@@ -1,71 +0,0 @@
-import { t as u } from "./libs/tinyrainbow.mjs";
-import { i as createLikeC4Logger } from "./module.mjs";
-import { i as chunkSizeWarningLimit, n as viteAliases, o as viteAppRoot, r as JsBanners } from "./config-app.prod.mjs";
-import { t as LikeC4VitePlugin } from "./plugin.mjs";
-import react from "@vitejs/plugin-react";
-
-//#region src/vite/config-webcomponent.prod.ts
-async function viteWebcomponentConfig({ languageServices, outDir, base, webcomponentPrefix = "likec4", filename = "likec4-views.js" }) {
-	const customLogger = createLikeC4Logger(["vite", "webcomponent"]);
-	const root = viteAppRoot();
-	customLogger.info(u.cyan("outDir") + " " + u.dim(outDir));
-	return {
-		root,
-		clearScreen: false,
-		base,
-		configFile: false,
-		publicDir: false,
-		mode: "production",
-		resolve: {
-			conditions: ["production"],
-			alias: viteAliases(),
-			dedupe: [
-				"react",
-				"react-dom",
-				"react/jsx-runtime",
-				"react/jsx-dev-runtime",
-				"react-dom/client"
-			]
-		},
-		define: {
-			WEBCOMPONENT_PREFIX: JSON.stringify(webcomponentPrefix),
-			"process.env.NODE_ENV": "\"production\""
-		},
-		esbuild: {
-			...JsBanners,
-			tsconfigRaw: { compilerOptions: {
-				target: "ESNext",
-				jsx: "react-jsx"
-			} }
-		},
-		build: {
-			outDir,
-			emptyOutDir: false,
-			sourcemap: false,
-			minify: true,
-			assetsInlineLimit: 1024 * 1024,
-			chunkSizeWarningLimit,
-			lib: {
-				entry: "src/webcomponent.js",
-				fileName(_format, _entryName) {
-					return filename;
-				},
-				formats: ["iife"],
-				name: "LikeC4Views"
-			},
-			rollupOptions: {
-				treeshake: { preset: "recommended" },
-				output: {
-					format: "iife",
-					hoistTransitiveImports: false,
-					compact: true
-				}
-			}
-		},
-		customLogger,
-		plugins: [react(), LikeC4VitePlugin({ languageServices: languageServices.languageServices })]
-	};
-}
-
-//#endregion
-export { viteWebcomponentConfig as t };