likec4 1.29.1 → 1.31.0

package/react/index.d.mts

@@ -8,9 +8,67 @@ type UnionToIntersection<Union> = (
 // `Union` into a [distributive conditional
 // type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
 Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection & Union : never;
+type KeysOfUnion<ObjectType> = 
+// Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
+type OptionalKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
+ ? (keyof {
+	[Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never;
+}) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
+ : never;
+type RequiredKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
+ ? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never;
+type IsNever<T> = [
+	T
+] extends [
+	never
+] ? true : false;
+type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
+type UnknownArray = readonly unknown[];
+type IsArrayReadonly<T extends UnknownArray> = IfNever<T, false, T extends unknown[] ? false : true>;
+type IfArrayReadonly<T extends UnknownArray, TypeIfArrayReadonly = true, TypeIfNotArrayReadonly = false> = IsArrayReadonly<T> extends infer Result ? Result extends true ? TypeIfArrayReadonly : TypeIfNotArrayReadonly : never;
+type NoInfer$1<T> = T extends infer U ? U : never;
+type IsAny<T> = 0 extends 1 & NoInfer$1<T> ? true : false;
+type IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
 type Simplify<T> = {
 	[KeyType in keyof T]: T[KeyType];
 } & {};
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType];
+};
+type PickIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType];
+};
+type SimpleMerge<Destination, Source> = {
+	[Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
+} & Source;
+type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
+type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny<T> extends true ? TypeIfAny : TypeIfNotAny);
+type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = {
+	[P in keyof T as Extract<P, Keys>]: T[P];
+};
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = IfAny<SpecifiedOptions, Defaults, IfNever<SpecifiedOptions, Defaults, Simplify<Merge<Defaults, {
+	[Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? Extract<SpecifiedOptions[Key], undefined> extends never ? Key : never : Key]: SpecifiedOptions[Key];
+}> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+>>;
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+type ExceptOptions = {
+	/**
+	Disallow assigning non-specified properties.
+
+	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+
+	@default false
+	*/
+	requireExactProps?: boolean;
+};
+type DefaultExceptOptions = {
+	requireExactProps: false;
+};
+type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = _Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
+type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = {
+	[KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options["requireExactProps"] extends true ? Partial<Record<KeysType, never>> : {});
 type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
 declare const tag: unique symbol;
 type TagContainer<Token> = {
@@ -20,6 +78,39 @@ type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{
 	[K in Token]: TagMetadata;
 }>;
 type Tagged<Type, TagName extends PropertyKey, TagMetadata = never> = Type & Tag<TagName, TagMetadata>;
+type SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? IfArrayReadonly<BaseType, Readonly<ResultantArray>, ResultantArray> : never : Simplify<
+// Pick just the keys that are optional from the base type.
+Except<BaseType, Keys> & 
+// Pick the keys that should be required from the base type and make them required.
+Required<HomomorphicPick<BaseType, Keys>>>;
+type SetArrayRequired<TArray extends UnknownArray, Keys, Counter extends any[] = [
+], Accumulator extends UnknownArray = [
+]> = TArray extends unknown // For distributing `TArray` when it's a union
+ ? keyof TArray & `${number}` extends never ? [
+	...Accumulator,
+	...TArray
+] : TArray extends readonly [
+	(infer First)?,
+	...infer Rest
+] ? "0" extends OptionalKeysOf<TArray> // If the first element of `TArray` is optional
+ ? `${Counter["length"]}` extends `${Keys & (string | number)}` // If the current index needs to be required
+ ? SetArrayRequired<Rest, Keys, [
+	...Counter,
+	any
+], [
+	...Accumulator,
+	First
+]> : [
+	...Accumulator,
+	...TArray
+] : SetArrayRequired<Rest, Keys, [
+	...Counter,
+	any
+], [
+	...Accumulator,
+	TArray[0]
+]> : never // Should never happen, since `[(infer F)?, ...infer R]` is a top-type for arrays.
+ : never;
 type TupleToUnion<ArrayType> = ArrayType extends readonly unknown[] ? ArrayType[number] : never;
 type NonEmptyArray<T> = [
 	T,
@@ -958,7 +1049,7 @@ type NodeDimensionChange = {
 	type: "dimensions";
 	dimensions?: Dimensions;
 	resizing?: boolean;
-	setAttributes?: boolean;
+	setAttributes?: boolean | "width" | "height";
 };
 type NodePositionChange = {
 	id: string;
@@ -2403,6 +2494,146 @@ type ControlsCustomLayoutProps = {
 	syncInProgressBadge: ReactNode;
 };
 type ControlsCustomLayout = (props: ControlsCustomLayoutProps) => ReactNode;
+type NodeProps$2<T extends Record<string, unknown> = {}, NodeType extends string = string> = NodeProps$1<Node$1<Base.NodeData & T, NodeType>>;
+type ReactFlowNode<Data extends Record<string, unknown>, NodeType extends string> = SetRequired<Node$1<Data, NodeType>, "type" | "initialWidth" | "initialHeight">;
+type ReactFlowEdge<Data extends Record<string, unknown>, EdgeType extends string> = SetRequired<Edge<Data, EdgeType>, "type" | "data">;
+declare namespace Base {
+	export type Dimmed = "immediate" | boolean;
+	export type NodeData = {
+		/**
+		 * Whether the cursor is hovering over the node
+		 */
+		hovered?: boolean;
+		/**
+		 * Whether the node is dimmed
+		 * 'immediate' means that the node is dimmed without delay
+		 */
+		dimmed?: Dimmed;
+	};
+	export type Node = Node$1<NodeData>;
+	export type NodeProps = NodeProps$1<Node$1<Base.NodeData, any>>;
+	export type EdgeData = {
+		/**
+		 * Whether the cursor is hovering over the edge
+		 */
+		hovered?: boolean;
+		/**
+		 * Whether the edge is active (animated and highlighted)
+		 */
+		active?: boolean;
+		/**
+		 * Whether the edge is dimmed
+		 * 'immediate' means that the edge is dimmed without delay
+		 */
+		dimmed?: Dimmed;
+	};
+	export type Edge = SetRequired<Edge<EdgeData>, "data">;
+	type WithDimmed = {
+		data: {
+			dimmed?: Dimmed;
+		};
+	};
+	type WithHovered = {
+		data: {
+			hovered?: boolean;
+		};
+	};
+	export function setDimmed<T extends WithDimmed>(value: T, dimmed: "immediate" | boolean): T;
+	export function setDimmed(dimmed: "immediate" | boolean): <T extends WithDimmed>(value: T) => T;
+	export function setHovered<T extends WithHovered>(value: T, hovered: boolean): T;
+	export function setHovered(hovered: boolean): <T extends WithHovered>(value: T) => T;
+	type WithData<D> = {
+		data: D;
+	};
+	export function setData<E extends WithData<any>>(value: E, state: Partial<E["data"]>): E;
+	export function setData<E extends WithData<any>>(state: Partial<E["data"]>): (value: E) => E;
+	export {};
+}
+type NonOptional<T extends object> = Simplify<{
+	[P in Exclude<keyof T, OptionalKeysOf<T>>]: T[P];
+} & {
+	[P in OptionalKeysOf<T>]-?: T[P] | undefined;
+}>;
+declare namespace Types {
+	type LeafNodeData = Base.NodeData & NonOptional<Pick<DiagramNode, "id" | "title" | "technology" | "description" | "color" | "shape" | "width" | "level" | "height" | "style" | "position">> & {
+		/**
+		 * View this node belongs to
+		 */
+		viewId: ViewId;
+		isMultiple?: boolean | undefined;
+		icon: string | null;
+	};
+	/**
+	 * Represents element from logical model
+	 */
+	type ElementNodeData = LeafNodeData & {
+		modelFqn: Fqn;
+		deploymentFqn?: never;
+		/**
+		 * If set - this node has navigation to another view and diagram has handler for this
+		 */
+		navigateTo: ViewId | null;
+	};
+	/**
+	 * Represents element from deployment model
+	 */
+	type DeploymentElementNodeData = LeafNodeData & {
+		navigateTo: ViewId | null;
+		deploymentFqn: Fqn;
+		modelFqn: Fqn | null;
+	};
+	type CompoundNodeData = Base.NodeData & NonOptional<Pick<DiagramNode, "id" | "title" | "color" | "shape" | "style" | "position">> & {
+		/**
+		 * View this node belongs to
+		 */
+		viewId: ViewId;
+		depth: number;
+		icon?: IconUrl;
+	};
+	type CompoundElementNodeData = CompoundNodeData & {
+		modelFqn: Fqn;
+		deploymentFqn?: never;
+		/**
+		 * If set - this node has navigation to another view and diagram has handler for this
+		 */
+		navigateTo: ViewId | null;
+	};
+	type CompoundDeploymentNodeData = CompoundNodeData & {
+		deploymentFqn: Fqn;
+		/**
+		 * If set - this node refers to a model element
+		 */
+		modelFqn: Fqn | null;
+		/**
+		 * If set - this node has navigation to another view and diagram has handler for this
+		 */
+		navigateTo: ViewId | null;
+	};
+	type ViewGroupNodeData = CompoundNodeData & {
+		isViewGroup: true;
+	};
+	type ElementNode = ReactFlowNode<ElementNodeData, "element">;
+	type DeploymentElementNode = ReactFlowNode<DeploymentElementNodeData, "deployment">;
+	type CompoundElementNode = ReactFlowNode<CompoundElementNodeData, "compound-element">;
+	type CompoundDeploymentNode = ReactFlowNode<CompoundDeploymentNodeData, "compound-deployment">;
+	type ViewGroupNode = ReactFlowNode<ViewGroupNodeData, "view-group">;
+	type Node = ElementNode | DeploymentElementNode | CompoundElementNode | CompoundDeploymentNode | ViewGroupNode;
+	type NodeData = Node["data"];
+	type RelationshipEdgeData = Simplify<Base.EdgeData & NonOptional<Pick<DiagramEdge, "id" | "label" | "labelBBox" | "technology" | "points" | "dir" | "color" | "line" | "head" | "tail" | "navigateTo" | "notes">> & {
+		labelXY: XYPosition | null;
+		controlPoints: XYPosition[] | undefined | null;
+	}>;
+	type RelationshipEdge = ReactFlowEdge<RelationshipEdgeData, "relationship">;
+	type Edge = RelationshipEdge;
+	type EdgeData = RelationshipEdgeData;
+}
+interface CustomNodes {
+	element?: undefined | ((props: NodeProps$2<Types.ElementNodeData, "element">) => ReactNode);
+	deployment?: undefined | ((props: NodeProps$2<Types.DeploymentElementNodeData, "deployment">) => ReactNode);
+	compoundElement?: undefined | ((props: NodeProps$2<Types.CompoundElementNodeData, "compound-element">) => ReactNode);
+	compoundDeployment?: undefined | ((props: NodeProps$2<Types.CompoundDeploymentNodeData, "compound-deployment">) => ReactNode);
+	viewGroup?: undefined | ((props: NodeProps$2<Types.ViewGroupNodeData, "view-group">) => ReactNode);
+}
 type DiagramNodeWithNavigate<ID = ViewId> = Omit<DiagramNode, "navigateTo"> & {
 	navigateTo: ID;
 };
@@ -2413,7 +2644,7 @@ type ElementIconRendererProps = {
 		icon?: string | null | undefined;
 	};
 };
-type ElementIconRenderer = (props: ElementIconRendererProps) => ReactNode;
+export type ElementIconRenderer = (props: ElementIconRendererProps) => ReactNode;
 type OnNavigateTo<ID = ViewId> = (to: ID, event?: ReactMouseEvent, element?: DiagramNodeWithNavigate<ID>) => void;
 type OnNodeClick = (node: DiagramNode, event: ReactMouseEvent) => void;
 type OnEdgeClick = (edge: DiagramEdge, event: ReactMouseEvent) => void;
@@ -2540,6 +2771,10 @@ interface LikeC4DiagramProperties {
 	 * Customize layout of the controls on the top left
 	 */
 	renderControls?: ControlsCustomLayout | undefined;
+	/**
+	 * Override node renderers
+	 */
+	renderNodes?: CustomNodes | undefined;
 	/**
 	 * Dynamic filter, applies both to nodes and edges
 	 */
@@ -2694,6 +2929,10 @@ export interface LikeC4ViewProps<ViewId = string, Tag = string, Kind = string> {
 	mantineTheme?: any;
 	/** Function to generate nonce attribute added to all generated `<style />` tags */
 	styleNonce?: string | (() => string) | undefined;
+	/**
+	 * Override node renderers
+	 */
+	renderNodes?: CustomNodes | undefined;
 	/**
 	 * Render custom icon for a node
 	 * By default, if icon is http:// or https://, it will be rendered as an image
@@ -2819,6 +3058,9 @@ type LikeC4ModelProviderProps = PropsWithChildren<{
 	likec4model: any;
 }>;
 export declare const LikeC4ModelProvider: (props: LikeC4ModelProviderProps) => JSX.Element;
+export declare const ViewNotFound: ({ viewId }: {
+	viewId: string;
+}) => import("react/jsx-runtime").JSX.Element;
 type AllKeys<T> = T extends any ? keyof T : never;
 type Primitive$1 = boolean | number | string;
 type ReadonlyIfObject<Value> = Value extends undefined ? Value : Value extends (...args: any) => any ? Value : Value extends Primitive$1 ? Value : Value extends object ? Readonly<Value> : Value;
@@ -3036,6 +3278,27 @@ interface Computed {
 	], cb: (...values: StoreValues<OriginStores>) => Task<Value> | Value): ReadableAtom<Value>;
 }
 declare const computed: Computed;
+interface Batched {
+	<Value, OriginStore extends Store>(stores: OriginStore, cb: (value: StoreValue<OriginStore>) => Task<Value> | Value): ReadableAtom<Value>;
+	/**
+	 * Create derived store, which use generates value from another stores.
+	 *
+	 * ```js
+	 * import { batched } from 'nanostores'
+	 *
+	 * const $sortBy = atom('id')
+	 * const $category = atom('')
+	 *
+	 * export const $link = batched([$sortBy, $category], (sortBy, category) => {
+	 *   return `/api/entities?sortBy=${sortBy}&category=${category}`
+	 * })
+	 * ```
+	 */
+	<Value, OriginStores extends AnyStore[]>(stores: [
+		...OriginStores
+	], cb: (...values: StoreValues<OriginStores>) => Task<Value> | Value): ReadableAtom<Value>;
+}
+declare const batched: Batched;
 type StoreKeys<T> = T extends {
 	setKey: (k: infer K, v: any) => unknown;
 } ? K : never;
@@ -3056,7 +3319,7 @@ declare function useStore<SomeStore extends Store>(store: SomeStore, options?: U
 export declare const createHooksForModel: ($atom: WritableAtom) => any;
 
 declare namespace nano {
-	export { Atom, WritableAtom, atom, computed, map, useStore };
+	export { Atom, WritableAtom, atom, batched, computed, map, useStore };
 }
 
 export {