@haneullabs/codegen 0.1.0

package/src/types/summary.ts

@@ -0,0 +1,144 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export interface ModuleSummary {
+	id: {
+		address: string;
+		name: string;
+	};
+	doc?: string | null;
+	immediate_dependencies: {
+		address: string;
+		name: string;
+	}[];
+	attributes?: Attribute[];
+	functions: Record<string, FunctionSummary>;
+	structs: Record<string, StructSummary>;
+	enums: Record<string, EnumSummary>;
+}
+
+export type Attribute =
+	| {
+			Name: string;
+	  }
+	| {
+			Assigned: [string, string];
+	  }
+	| {
+			Parameterized: [string, Attribute[]];
+	  };
+
+export interface FunctionSummary {
+	source_index?: number;
+	index: number;
+	doc?: string | null;
+	attributes?: Attribute[];
+	visibility: FunctionVisibility;
+	entry: boolean;
+	macro_?: boolean;
+	type_parameters: DatatypeParameter[];
+	parameters: Parameter[];
+	return_: Type[];
+}
+
+export interface StructSummary {
+	index: number;
+	doc?: string | null;
+	attributes?: Attribute[];
+	abilities: Ability[];
+	type_parameters: DatatypeParameter[];
+	fields: Fields;
+}
+
+export interface EnumSummary {
+	index: number;
+	doc?: string | null;
+	attributes?: Attribute[];
+	abilities: Ability[];
+	type_parameters: DatatypeParameter[];
+	variants: Record<string, Variant>;
+}
+
+export interface Variant {
+	index: number;
+	doc?: string | null;
+	fields: Fields;
+}
+
+export interface Fields {
+	positional_fields: boolean;
+	fields: Record<string, Field>;
+}
+
+export interface Field {
+	index: number;
+	doc?: string | null;
+	type_: Type;
+}
+
+export interface TypeParameter {
+	name?: string;
+	constraints: Ability[];
+}
+
+export interface DatatypeParameter extends TypeParameter {
+	phantom: boolean;
+}
+
+export type Ability = 'Drop' | 'Copy' | 'Key' | 'Store';
+
+export interface Parameter {
+	name?: string;
+	type_: Type;
+}
+
+export type Type =
+	| 'bool'
+	| 'u8'
+	| 'u16'
+	| 'u32'
+	| 'u64'
+	| 'u128'
+	| 'u256'
+	| 'address'
+	| 'signer'
+	| '_'
+	| {
+			Datatype: Datatype;
+	  }
+	| {
+			vector: Type;
+	  }
+	| {
+			Reference: [boolean, Type];
+	  }
+	| {
+			TypeParameter: number;
+	  }
+	| {
+			NamedTypeParameter: string;
+	  }
+	| {
+			tuple: Type[];
+	  }
+	| {
+			fun: [Type[], Type];
+	  };
+
+export interface Datatype {
+	module: ModuleId;
+	name: string;
+	type_arguments: TypeArgument[];
+}
+
+export interface TypeArgument {
+	phantom: boolean;
+	argument: Type;
+}
+
+export interface ModuleId {
+	address: string;
+	name: string;
+}
+
+export type FunctionVisibility = 'Public' | 'Friend' | 'Package' | 'Private';

package/src/utils.ts

@@ -0,0 +1,180 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+import { format } from 'prettier';
+import ts from 'typescript';
+import type { Type } from './types/summary.js';
+import { HANEUL_FRAMEWORK_ADDRESS, HANEUL_SYSTEM_ADDRESS } from './render-types.js';
+
+export function printNodes(...nodes: ts.Node[]) {
+	const printer = ts.createPrinter({
+		removeComments: false,
+	});
+
+	return nodes
+		.map((node) => printer.printNode(ts.EmitHint.Unspecified, node, node.getSourceFile()))
+		.join('\n');
+}
+
+type TSTemplateValue = string | number | boolean | ts.Statement[] | ts.Expression;
+
+export function parseTS(strings: TemplateStringsArray, ...values: TSTemplateValue[]) {
+	const source = strings.reduce((acc, str, i) => {
+		if (typeof values[i] === 'object') {
+			if (Array.isArray(values[i])) {
+				return `${acc}${str}${printNodes(...values[i])}`;
+			}
+
+			return `${acc}${str}${printNodes(values[i])}`;
+		}
+
+		return `${acc}${str}${values[i] ?? ''}`;
+	}, '');
+
+	const lines = source.replace(/^\s/m, '').split('\n');
+	const firstLine = lines[0];
+	const indent = firstLine.match(/^\s*/)?.[0] ?? '';
+	const unIndented = lines.map((line) => line.replace(indent, '')).join('\n');
+
+	const sourceFile = ts.createSourceFile('file.ts', unIndented, ts.ScriptTarget.Latest, true);
+	return [...sourceFile.statements.values()];
+}
+
+export async function mapToObject<T>({
+	items,
+	mapper,
+	getComment,
+}: {
+	items: Iterable<T>;
+	mapper: (item: T) => Promise<null | [string, TSTemplateValue]> | null | [string, TSTemplateValue];
+	getComment?: (item: T) => string | null | undefined;
+}) {
+	const fieldProps = await Promise.all(
+		(
+			await Promise.all(
+				[...items].map(async (item) => {
+					const mapped = await mapper(item);
+					if (!mapped) {
+						return null;
+					}
+
+					const [key, value] = mapped;
+					return [item, key, value] as const;
+				}),
+			)
+		)
+			.filter((value) => value !== null)
+			.map(([item, key, value]) => {
+				const [node] = parseTS /* ts */ `({${key}: ${value}})`;
+
+				if (!ts.isExpressionStatement(node)) {
+					throw new Error('Expected Expression statement');
+				}
+
+				if (!ts.isParenthesizedExpression(node.expression)) {
+					throw new Error('Expected Parenthesized Expression');
+				}
+
+				if (!ts.isObjectLiteralExpression(node.expression.expression)) {
+					throw new Error('Expected Object Literal Expression');
+				}
+
+				const comment = getComment?.(item);
+				return withComment({ comment }, node.expression.expression.properties[0]);
+			}),
+	);
+
+	return ts.factory.createObjectLiteralExpression(fieldProps, true);
+}
+
+export async function withComment<T extends ts.Node | ts.Node[]>(
+	options:
+		| { comment?: string | null; doc?: never }
+		| { doc?: string | null | undefined; comment?: never },
+	nodes: T,
+): Promise<T> {
+	const comment = options.comment ?? options.doc;
+
+	if (comment) {
+		const firstNode = Array.isArray(nodes) ? nodes[0] : (nodes as ts.Node);
+		ts.addSyntheticLeadingComment(
+			firstNode,
+			ts.SyntaxKind.MultiLineCommentTrivia,
+			await formatComment(comment),
+			true,
+		);
+	}
+
+	return nodes;
+}
+
+export async function formatComment(text: string) {
+	const lines = (
+		await format(text, {
+			printWidth: 80,
+			semi: true,
+			singleQuote: true,
+			tabWidth: 2,
+			trailingComma: 'all',
+			useTabs: true,
+			proseWrap: 'always',
+			parser: 'markdown',
+		})
+	)
+		.trim()
+		.replaceAll('*/', '*\\/')
+		.split('\n');
+
+	if (lines.length === 1) return `* ${lines[0]} `;
+
+	return `*\n${lines.map((line) => ` * ${line}`).join('\n')}\n `;
+}
+
+export function camelCase(str: string) {
+	return str.replaceAll(/(?:_)([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+
+export function capitalize(str: string) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export function isWellKnownObjectParameter(
+	type: Type,
+	resolveAddress: (address: string) => string,
+) {
+	if (typeof type === 'string') {
+		return false;
+	}
+
+	if ('Reference' in type) {
+		return isWellKnownObjectParameter(type.Reference[1], resolveAddress);
+	}
+
+	if (!('Datatype' in type)) {
+		return false;
+	}
+
+	const { Datatype } = type;
+
+	const address = resolveAddress(Datatype.module.address);
+	if (address === HANEUL_FRAMEWORK_ADDRESS) {
+		if (Datatype.module.name === 'deny_list') {
+			return Datatype.name === 'DenyList';
+		}
+
+		if (Datatype.module.name === 'random') {
+			return Datatype.name === 'Random';
+		}
+
+		if (Datatype.module.name === 'clock') {
+			return Datatype.name === 'Clock';
+		}
+	}
+
+	if (address === HANEUL_SYSTEM_ADDRESS) {
+		if (Datatype.module.name === 'haneul_system') {
+			return Datatype.name === 'HaneulSystemState';
+		}
+	}
+
+	return false;
+}