@azure-net/cli 5.1.1 → 6.0.0-next.2

package/src/scaffolds/createPresenterFactory.ts

@@ -1,102 +0,0 @@
-import fs from 'node:fs/promises';
-import fsSync from 'node:fs';
-import path from 'node:path';
-import prompts from 'prompts';
-import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
-import { toPascalCase } from '../utils/contextUtils.js';
-import { getFoundationConstructPath, getSharedState } from '../utils/sharedFoundation.js';
-
-type ConfigPath = 'ts' | 'js';
-
-const createPresenterFactoryTemplate = (
-	factoryName: string
-): string => `import { createAsyncHelpers, createPresenterFactory } from '@azure-net/kit/delivery';
-
-export const AsyncHelpers = createAsyncHelpers();
-
-export const ${factoryName} = createPresenterFactory({ ...AsyncHelpers });
-`;
-
-const resolveConfigFile = (cwd: string): { filepath: string; type: ConfigPath; exists: boolean; content: string } => {
-	const tsPath = path.join(cwd, 'azure-net.config.ts');
-	const jsPath = path.join(cwd, 'azure-net.config.js');
-
-	if (fsSync.existsSync(tsPath)) {
-		return { filepath: tsPath, type: 'ts', exists: true, content: fsSync.readFileSync(tsPath, 'utf-8') };
-	}
-	if (fsSync.existsSync(jsPath)) {
-		return { filepath: jsPath, type: 'js', exists: true, content: fsSync.readFileSync(jsPath, 'utf-8') };
-	}
-
-	return { filepath: tsPath, type: 'ts', exists: false, content: '' };
-};
-
-const buildDefaultPresenterFactoryConfigEntry = (factoryName: string): string => {
-	return `defaultPresenterFactory: '${factoryName}'`;
-};
-
-const upsertDefaultPresenterFactoryConfig = (content: string, factoryName: string): string => {
-	const hasExportDefaultObject = /export\s+default\s*\{[\s\S]*\}\s*;?/.test(content);
-	const defaultFactoryEntry = buildDefaultPresenterFactoryConfigEntry(factoryName);
-
-	if (!hasExportDefaultObject) {
-		return `export default {\n\t${defaultFactoryEntry}\n};\n`;
-	}
-
-	let nextContent = content;
-
-	if (/defaultPresenterFactory\s*:/.test(nextContent)) {
-		nextContent = nextContent.replace(/defaultPresenterFactory\s*:\s*(\{[\s\S]*?\n\s*\}|['"`][^'"`]+['"`])/m, defaultFactoryEntry);
-	} else if (/defaultPresenter\s*:/.test(nextContent)) {
-		nextContent = nextContent.replace(/defaultPresenter\s*:\s*(\{[\s\S]*?\n\s*\}|['"`][^'"`]+['"`])/m, defaultFactoryEntry);
-	} else {
-		nextContent = nextContent.replace(/export\s+default\s*\{([\s\S]*)\}\s*;?/, (_full, body: string) => {
-			const trimmedRight = body.replace(/\s*$/, '');
-			if (!trimmedRight.length) {
-				return `export default {\n\t${defaultFactoryEntry}\n};`;
-			}
-
-			const withComma = trimmedRight.endsWith(',') ? trimmedRight : `${trimmedRight},`;
-			return `export default {${withComma}\n\t${defaultFactoryEntry}\n};`;
-		});
-	}
-	return nextContent;
-};
-
-export default async function createPresenterFactory(): Promise<void> {
-	const { presenterFactoryNameRaw } = await prompts({
-		type: 'text',
-		name: 'presenterFactoryNameRaw',
-		message: 'Presenter factory name:',
-		initial: 'AppPresenter'
-	});
-
-	const presenterFactoryName = toPascalCase(String(presenterFactoryNameRaw ?? 'AppPresenter')) || 'AppPresenter';
-	const { sharedContext } = await getSharedState();
-	const presenterRootPath = getFoundationConstructPath(sharedContext.name, 'presenter');
-	const filePath = path.join(presenterRootPath, `${presenterFactoryName}.ts`);
-
-	await fs.mkdir(presenterRootPath, { recursive: true });
-
-	const created = await writeIfNotExists(filePath, createPresenterFactoryTemplate(presenterFactoryName));
-	if (!created) {
-		console.log(`⚠️ Presenter factory "${presenterFactoryName}" already exists. File was not overwritten.`);
-	} else {
-		await updateIndexTs(presenterRootPath);
-		console.log(`✅ Presenter factory created: ${filePath}`);
-	}
-
-	const { useAsDefault } = await prompts({
-		type: 'confirm',
-		name: 'useAsDefault',
-		message: 'Use this presenter factory as default for the project?',
-		initial: true
-	});
-
-	if (!useAsDefault) return;
-
-	const config = resolveConfigFile(process.cwd());
-	const nextContent = upsertDefaultPresenterFactoryConfig(config.content, presenterFactoryName);
-	await fs.writeFile(config.filepath, nextContent, 'utf-8');
-	console.log(`✅ Default presenter factory saved to ${path.basename(config.filepath)}`);
-}

package/src/scaffolds/createProgram.ts

@@ -1,19 +0,0 @@
-import path from 'node:path';
-import { writeIfNotExists } from '../utils/fileUtils.js';
-
-const createProgramTemplate = (): string => `import { createApp } from '@azure-net/kit';
-
-export const { register, Container } = createApp((app) => app);
-`;
-
-export default async function createProgram(): Promise<void> {
-	const programPath = path.join(process.cwd(), 'src', 'program.ts');
-	const created = await writeIfNotExists(programPath, createProgramTemplate());
-
-	if (!created) {
-		console.log('⚠️ Program already exists. Nothing was overwritten.');
-		return;
-	}
-
-	console.log(`✅ Program created: ${programPath}`);
-}

package/src/scaffolds/createResponse.ts

@@ -1,66 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import prompts from 'prompts';
-import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
-import { toPascalCase } from '../utils/contextUtils.js';
-import { getFoundationConstructPath, getSharedState } from '../utils/sharedFoundation.js';
-
-const createResponseWithWrapperTemplate = (name: string): string => {
-	const interfaceName = `I${name}`;
-	return `import { ResponseBuilder } from '@azure-net/kit/infra';
-
-export interface ${interfaceName}<T> {
-\tdata: T;
-}
-
-export class ${name}<TData = unknown, TMeta = unknown> extends ResponseBuilder<TData, TMeta, ${interfaceName}<TData>> {
-\tprotected unwrapData(data: ${interfaceName}<TData>): TData {
-\t\treturn data.data;
-\t}
-}
-`;
-};
-
-const createResponseSimpleTemplate = (name: string): string => `import { ResponseBuilder } from '@azure-net/kit/infra';
-
-export class ${name}<TData = unknown, TMeta = unknown> extends ResponseBuilder<TData, TMeta> {}
-`;
-
-const ensureResponseName = (rawName: string): string => {
-	const normalized = toPascalCase(rawName || 'ApiResponse') || 'ApiResponse';
-	return normalized.endsWith('Response') ? normalized : `${normalized}Response`;
-};
-
-export default async function createResponse(): Promise<void> {
-	const { responseNameRaw } = await prompts({
-		type: 'text',
-		name: 'responseNameRaw',
-		message: 'Response class name:',
-		initial: 'ApiResponse'
-	});
-
-	const responseName = ensureResponseName(String(responseNameRaw ?? 'ApiResponse'));
-
-	const { useCommonResponseWrapper } = await prompts({
-		type: 'confirm',
-		name: 'useCommonResponseWrapper',
-		message: 'Use common backend response wrapper interface?',
-		initial: true
-	});
-
-	const { sharedContext } = await getSharedState();
-	const responseRoot = getFoundationConstructPath(sharedContext.name, 'response');
-	const filePath = path.join(responseRoot, `${responseName}.ts`);
-	await fs.mkdir(responseRoot, { recursive: true });
-
-	const template = useCommonResponseWrapper ? createResponseWithWrapperTemplate(responseName) : createResponseSimpleTemplate(responseName);
-	const created = await writeIfNotExists(filePath, template);
-	await updateIndexTs(responseRoot);
-
-	if (!created) {
-		console.log(`⚠️ Response "${responseName}" already exists. File was not overwritten.`);
-		return;
-	}
-
-	console.log(`✅ Response created: ${filePath}`);
-}

package/src/scaffolds/createSchemaRule.ts

@@ -1,44 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import prompts from 'prompts';
-import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
-import { toPascalCase, toCamelCase } from '../utils/contextUtils.js';
-import { getFoundationConstructPath, getSharedState } from '../utils/sharedFoundation.js';
-
-const createSchemaRuleTemplate = (
-	ruleName: string
-): string => `import type { ValidationParams, ValidationRuleResult } from '@azure-net/kit/delivery';
-
-export const ${ruleName} = <T = unknown, D = unknown>(): ValidationRuleResult<T, D> => {
-\treturn (validationParams: ValidationParams<T, D>) => {
-\t\treturn undefined;
-\t};
-};
-`;
-
-export default async function createSchemaRule(): Promise<void> {
-	const { ruleNameRaw } = await prompts({
-		type: 'text',
-		name: 'ruleNameRaw',
-		message: 'Schema rule name:',
-		initial: 'File'
-	});
-
-	const pascalName = toPascalCase(String(ruleNameRaw ?? 'File')) || 'File';
-	const camelName = toCamelCase(pascalName) || 'file';
-	const { sharedContext } = await getSharedState();
-	const rulesPath = path.join(getFoundationConstructPath(sharedContext.name, 'schema'), 'custom-rules');
-	const filePath = path.join(rulesPath, `${pascalName}.ts`);
-
-	await fs.mkdir(rulesPath, { recursive: true });
-
-	const created = await writeIfNotExists(filePath, createSchemaRuleTemplate(camelName));
-	await updateIndexTs(rulesPath);
-
-	if (!created) {
-		console.log(`⚠️ Schema rule "${pascalName}" already exists. File was not overwritten.`);
-		return;
-	}
-
-	console.log(`✅ Schema rule created: ${filePath}`);
-}

package/src/scaffolds/createTranslationManager.ts

@@ -1,80 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import prompts from 'prompts';
-import { writeIfNotExists } from '../utils/fileUtils.js';
-import { getLocalizationPath, getSharedState } from '../utils/sharedFoundation.js';
-
-const parseLocales = (rawLocales: string): string[] => {
-	const parsed = String(rawLocales ?? '')
-		.split(',')
-		.map((item) => item.trim().toLowerCase())
-		.filter(Boolean);
-
-	const unique = Array.from(new Set(parsed));
-	return unique.length ? unique : ['en', 'ru'];
-};
-
-const createTranslationIndexTemplate = (defaultLocale: string): string => `import { messages } from './locales/index.js';
-import { createTranslations, type Path } from '@azure-net/kit/i18n';
-
-export const TranslationManager = createTranslations({
-\tmessages,
-\tinitLang: '${defaultLocale}',
-\tinitLangFromAcceptLanguage: true,
-\tcookieName: 'current-language'
-});
-
-type MessagesList = Awaited<ReturnType<(typeof messages)[keyof typeof messages]>>;
-type TranslationExtended = { key: MessageKeys | string; vars?: Record<string, unknown> };
-
-export type MessageKeys = Path<MessagesList>;
-export type TranslationParam = MessageKeys | string | TranslationExtended;
-export type AvailableLocales = keyof typeof messages;
-`;
-
-const createLocalesIndexTemplate = (locales: string[]): string => {
-	const lines = locales.map((locale) => `\t${locale}: () => import('./${locale}/index.js').then((res) => res.default)`);
-	return `export const messages = {\n${lines.join(',\n')}\n};\n`;
-};
-
-const createLocaleTemplate = (): string => `export default {
-\ttest: 'test'
-};
-`;
-
-export default async function createTranslationManager(): Promise<void> {
-	const { localesRaw } = await prompts({
-		type: 'text',
-		name: 'localesRaw',
-		message: 'Enter locales (comma separated):',
-		initial: 'en, ru'
-	});
-
-	const locales = parseLocales(String(localesRaw ?? 'en, ru'));
-
-	const { defaultLocale } = await prompts({
-		type: 'select',
-		name: 'defaultLocale',
-		message: 'Choose default locale:',
-		choices: locales.map((locale) => ({ title: locale, value: locale })),
-		initial: 0
-	});
-
-	const selectedDefaultLocale = String(defaultLocale ?? locales[0] ?? 'en');
-
-	const { sharedContext } = await getSharedState();
-	const translationRoot = getLocalizationPath(sharedContext.name);
-	const localesRoot = path.join(translationRoot, 'locales');
-	await fs.mkdir(localesRoot, { recursive: true });
-
-	await writeIfNotExists(path.join(translationRoot, 'index.ts'), createTranslationIndexTemplate(selectedDefaultLocale));
-	await writeIfNotExists(path.join(localesRoot, 'index.ts'), createLocalesIndexTemplate(locales));
-
-	for (const locale of locales) {
-		const localeDir = path.join(localesRoot, locale);
-		await fs.mkdir(localeDir, { recursive: true });
-		await writeIfNotExists(path.join(localeDir, 'index.ts'), createLocaleTemplate());
-	}
-
-	console.log(`✅ Translation manager created: ${translationRoot}`);
-}

package/src/utils/contextUtils.ts

@@ -1,88 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import prompts from 'prompts';
-import { loadUserConfig } from './loadConfig.js';
-
-const APP_PATH = path.join(process.cwd(), 'src/app');
-
-function normalizeContextNames(rawContexts: unknown): string[] {
-	if (!Array.isArray(rawContexts)) return [];
-
-	return rawContexts
-		.map((item) => {
-			if (typeof item === 'string') {
-				return item.trim();
-			}
-			if (!item || typeof item !== 'object') return '';
-			return String(item.name ?? '').trim();
-		})
-		.filter(Boolean);
-}
-
-export async function selectContext(message = 'Select context:'): Promise<string | null> {
-	const config = await loadUserConfig();
-	const contexts = normalizeContextNames(config.contexts);
-
-	const { context } = await prompts({
-		type: 'select',
-		name: 'context',
-		message,
-		choices: contexts.map((c) => ({ title: c, value: c }))
-	});
-
-	return context ? String(context) : null;
-}
-
-export function getContextPath(context: string): string {
-	return path.join(APP_PATH, context, 'layers');
-}
-
-export async function getAvailableFiles(dir: string, pattern = '.ts'): Promise<string[]> {
-	try {
-		const files = await fs.readdir(dir);
-		return files.filter((f) => f.endsWith(pattern) && f !== 'index.ts').map((f) => f.replace(pattern, ''));
-	} catch {
-		return [];
-	}
-}
-
-export async function getApplicationProviderServices(context: string): Promise<string[]> {
-	const contextPath = getContextPath(context);
-	const providerPath = path.join(contextPath, 'application/providers/ApplicationProvider.ts');
-
-	try {
-		const content = await fs.readFile(providerPath, 'utf-8');
-		// Extract service names from ApplicationProvider
-		const serviceRegex = /(\w+Service):\s*\(/g;
-		const services: string[] = [];
-		let match;
-
-		while ((match = serviceRegex.exec(content)) !== null) {
-			const serviceName = match[1];
-			if (serviceName) services.push(serviceName);
-		}
-
-		return services;
-	} catch {
-		return [];
-	}
-}
-
-export function toPascalCase(str: string): string {
-	return str
-		.split(/[-_\s]+/)
-		.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-		.join('');
-}
-
-export function toCamelCase(str: string): string {
-	const pascal = toPascalCase(str);
-	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
-}
-
-export function toKebabCase(str: string): string {
-	return str
-		.replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-		.replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
-		.toLowerCase();
-}

package/src/utils/fileUtils.ts

@@ -1,74 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-
-export async function writeIfNotExists(filepath: string, content: string): Promise<boolean> {
-	try {
-		await fs.access(filepath);
-		console.log(`⚠️  Skip existing: ${filepath}`);
-		return false;
-	} catch {
-		await fs.mkdir(path.dirname(filepath), { recursive: true });
-		await fs.writeFile(filepath, content, 'utf-8');
-		console.log(`✅ Created: ${filepath}`);
-		return true;
-	}
-}
-
-export async function updateIndexTs(dir: string, filePattern = '.ts', ignore: string[] = ['index.ts']): Promise<void> {
-	try {
-		const files = (await fs.readdir(dir)).filter((f) => f.endsWith(filePattern) && !ignore.includes(f));
-		const content = files.map((f) => `export * from './${f.replace('.ts', '')}';`).join('\n') + '\n';
-		await fs.writeFile(path.join(dir, 'index.ts'), content, 'utf-8');
-	} catch {
-		// Directory doesn't exist yet
-	}
-}
-
-export async function ensureIndexExports(layerPath: string): Promise<void> {
-	try {
-		const subdirs = await fs.readdir(layerPath, { withFileTypes: true });
-		const exportLines = subdirs.filter((d) => d.isDirectory()).map((d) => `export * from './${d.name}';`);
-
-		if (exportLines.length > 0) {
-			await fs.writeFile(path.join(layerPath, 'index.ts'), exportLines.join('\n') + '\n', 'utf-8');
-		}
-	} catch {
-		// Directory doesn't exist
-	}
-}
-
-export async function injectIntoFile(
-	filepath: string,
-	searchPattern: string,
-	newContent: string,
-	position: 'after' | 'before' = 'after'
-): Promise<boolean> {
-	try {
-		let content = await fs.readFile(filepath, 'utf-8');
-		const index = content.indexOf(searchPattern);
-
-		if (index === -1) {
-			console.warn(`Pattern not found in ${filepath}`);
-			return false;
-		}
-
-		if (content.includes(newContent.trim())) {
-			console.log(`Content already exists in ${filepath}`);
-			return false;
-		}
-
-		if (position === 'after') {
-			const insertIndex = index + searchPattern.length;
-			content = content.slice(0, insertIndex) + '\n' + newContent + content.slice(insertIndex);
-		} else {
-			content = content.slice(0, index) + newContent + '\n' + content.slice(index);
-		}
-
-		await fs.writeFile(filepath, content, 'utf-8');
-		console.log(`✅ Updated: ${filepath}`);
-		return true;
-	} catch (error: unknown) {
-		console.error(`Failed to update ${filepath}:`, error instanceof Error ? error.message : String(error));
-		return false;
-	}
-}

package/src/utils/loadConfig.ts

@@ -1,68 +0,0 @@
-import fs from 'node:fs/promises';
-import fsSync from 'node:fs';
-import path from 'node:path';
-
-export type AzureNetConfig = {
-	contexts: Array<string | { name?: string; alias?: string }>;
-	defaultContext: string;
-	sharedAlias?: string;
-	packageManager?: string;
-	defaultSchemaFactory?: string;
-	defaultPresenterFactory?: string;
-	groupRoutesFunc?: unknown;
-	[key: string]: unknown;
-};
-
-const DEFAULT_CONFIG: AzureNetConfig = {
-	contexts: [],
-	defaultContext: 'web'
-};
-
-function toObjectFromDefaultExport(content: string): Record<string, unknown> {
-	const source = String(content ?? '').trim();
-	if (!source.length) return {};
-
-	const replacedExport = source.replace(/^\s*export\s+default\s+/m, 'return ');
-	if (replacedExport === source) return {};
-
-	const withSemicolon = /;\s*$/.test(replacedExport) ? replacedExport : `${replacedExport};`;
-
-	try {
-		return new Function(withSemicolon)() ?? {};
-	} catch {
-		return {};
-	}
-}
-
-export function resolveConfigFile(cwd = process.cwd()): { exists: boolean; filepath: string; type: 'ts' | 'js' } {
-	const tsPath = path.join(cwd, 'azure-net.config.ts');
-	const jsPath = path.join(cwd, 'azure-net.config.js');
-
-	if (fsSync.existsSync(tsPath)) {
-		return { exists: true, filepath: tsPath, type: 'ts' };
-	}
-	if (fsSync.existsSync(jsPath)) {
-		return { exists: true, filepath: jsPath, type: 'js' };
-	}
-
-	return { exists: false, filepath: tsPath, type: 'ts' };
-}
-
-export async function loadUserConfig(): Promise<AzureNetConfig> {
-	const { exists, filepath } = resolveConfigFile();
-	if (!exists) {
-		return { ...DEFAULT_CONFIG };
-	}
-
-	try {
-		const content = await fs.readFile(filepath, 'utf-8');
-		const parsed = toObjectFromDefaultExport(content);
-		if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-			return { ...DEFAULT_CONFIG };
-		}
-
-		return { ...DEFAULT_CONFIG, ...(parsed as Record<string, unknown>) };
-	} catch {
-		return { ...DEFAULT_CONFIG };
-	}
-}

package/src/utils/sharedFoundation.ts

@@ -1,70 +0,0 @@
-import path from 'node:path';
-import { normalizeContexts } from '../init/initAliases.js';
-import { loadUserConfig, resolveConfigFile } from './loadConfig.js';
-
-export type FoundationConstruct = 'datasource' | 'presenter' | 'provider' | 'response' | 'schema';
-export type ContextConfig = { name: string; alias: string };
-
-export const SHARED_ESSENTIALS_DIR_NAME = 'essentials';
-
-const normalizeAlias = (value: unknown): string => {
-	const raw = String(value ?? '').trim();
-	return raw.startsWith('$') ? raw : `$${raw}`;
-};
-
-const createMissingSharedAliasError = (): Error =>
-	new Error(
-		'`sharedAlias` is missing in azure-net.config.ts/js. Add sharedAlias and make sure it points to one of `contexts`, for example: sharedAlias: "$shared-kernel".'
-	);
-
-export const getSharedState = async (): Promise<{ contexts: ContextConfig[]; sharedAlias: string; sharedContext: ContextConfig }> => {
-	const config = await loadUserConfig();
-	const contexts = normalizeContexts(config.contexts) as ContextConfig[];
-	const sharedAliasRaw = String(config.sharedAlias ?? '').trim();
-
-	if (!sharedAliasRaw.length) throw createMissingSharedAliasError();
-
-	const sharedAlias = normalizeAlias(sharedAliasRaw);
-	const sharedContext = contexts.find((context) => normalizeAlias(context.alias) === sharedAlias);
-
-	if (!sharedContext) {
-		throw new Error(
-			`sharedAlias "${sharedAlias}" does not point to any configured context. Add a context with alias "${sharedAlias}" in azure-net.config.ts/js.`
-		);
-	}
-
-	return {
-		contexts,
-		sharedAlias,
-		sharedContext
-	};
-};
-
-export const hasSharedAliasConfig = async (): Promise<boolean> => {
-	const config = await loadUserConfig();
-	return String(config.sharedAlias ?? '').trim().length > 0;
-};
-
-export const getSharedContextRootPath = (sharedContextName: string): string => path.join(process.cwd(), 'src', 'app', sharedContextName);
-
-export const getSharedEssentialsPath = (sharedContextName: string): string =>
-	path.join(getSharedContextRootPath(sharedContextName), SHARED_ESSENTIALS_DIR_NAME);
-
-export const getFoundationRootPath = (sharedContextName: string): string =>
-	path.join(getSharedEssentialsPath(sharedContextName), 'foundation', 'constructs');
-
-export const getFoundationConstructPath = (sharedContextName: string, construct: FoundationConstruct): string =>
-	path.join(getFoundationRootPath(sharedContextName), construct);
-
-export const getFoundationConstructImportPath = (sharedAlias: string, construct: FoundationConstruct): string =>
-	`${sharedAlias}/${SHARED_ESSENTIALS_DIR_NAME}/foundation/constructs/${construct}`;
-
-export const getLocalizationPath = (sharedContextName: string): string =>
-	path.join(getSharedEssentialsPath(sharedContextName), 'localization');
-
-export const getLocalizationImportPath = (sharedAlias: string): string => `${sharedAlias}/${SHARED_ESSENTIALS_DIR_NAME}/localization`;
-
-export const getConfigFileLabel = (): string => {
-	const config = resolveConfigFile();
-	return config.exists ? path.basename(config.filepath) : 'azure-net.config.ts/js';
-};

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-	"compilerOptions": {
-		"target": "ES2022",
-		"module": "NodeNext",
-		"moduleResolution": "NodeNext",
-		"rootDir": ".",
-		"outDir": "dist",
-		"allowJs": true,
-		"checkJs": false,
-		"declaration": true,
-		"sourceMap": true,
-		"strict": true,
-		"noUncheckedIndexedAccess": true,
-		"esModuleInterop": true,
-		"skipLibCheck": true
-	},
-	"include": ["bin/**/*.ts", "src/**/*"],
-	"exclude": ["dist", "node_modules"]
-}