proteum 2.0.0 → 2.1.0

package/cli/commands/doctor.ts

@@ -0,0 +1,108 @@
+import path from 'path';
+
+import cli from '..';
+import Compiler from '../compiler';
+import {
+    readProteumManifest,
+    type TProteumManifest,
+    type TProteumManifestDiagnostic,
+} from '../compiler/common/proteumManifest';
+
+const allowedDoctorArgs = new Set(['json', 'strict']);
+
+const validateDoctorArgs = () => {
+    const enabledArgs = Object.entries(cli.args)
+        .filter(([name, value]) => name !== 'workdir' && name !== 'verbose' && value === true)
+        .map(([name]) => name);
+
+    const invalidArgs = enabledArgs.filter((arg) => !allowedDoctorArgs.has(arg));
+
+    if (invalidArgs.length > 0) {
+        throw new Error(
+            `Unknown doctor argument(s): ${invalidArgs.join(', ')}. Allowed values: ${[...allowedDoctorArgs].join(', ')}.`,
+        );
+    }
+};
+
+const normalizePath = (value: string) => value.replace(/\\/g, '/');
+
+const formatFilepath = (manifest: TProteumManifest, filepath: string) => {
+    const normalizedFilepath = normalizePath(filepath);
+    const normalizedAppRoot = normalizePath(manifest.app.root);
+    const normalizedCoreRoot = normalizePath(manifest.app.coreRoot);
+
+    if (normalizedFilepath === normalizedAppRoot) return '.';
+    if (normalizedFilepath.startsWith(normalizedAppRoot + '/'))
+        return normalizePath(path.relative(normalizedAppRoot, normalizedFilepath)) || '.';
+
+    if (normalizedFilepath === normalizedCoreRoot) return 'node_modules/proteum';
+    if (normalizedFilepath.startsWith(normalizedCoreRoot + '/'))
+        return normalizePath(path.join('node_modules/proteum', path.relative(normalizedCoreRoot, normalizedFilepath)));
+
+    return normalizedFilepath;
+};
+
+const formatLocation = (diagnostic: TProteumManifestDiagnostic) =>
+    diagnostic.sourceLocation ? `:${diagnostic.sourceLocation.line}:${diagnostic.sourceLocation.column}` : '';
+
+const renderGroup = (manifest: TProteumManifest, diagnostics: TProteumManifestDiagnostic[], title: string) => {
+    if (diagnostics.length === 0) return `${title}\n- none`;
+
+    return [
+        title,
+        ...diagnostics.map((diagnostic) => {
+            const related =
+                diagnostic.relatedFilepaths && diagnostic.relatedFilepaths.length > 0
+                    ? ` related=${diagnostic.relatedFilepaths.map((filepath) => formatFilepath(manifest, filepath)).join(',')}`
+                    : '';
+
+            return `- ${diagnostic.code} ${diagnostic.message} source=${formatFilepath(manifest, diagnostic.filepath)}${formatLocation(diagnostic)}${related}`;
+        }),
+    ].join('\n');
+};
+
+export const run = async (): Promise<void> => {
+    validateDoctorArgs();
+
+    const compiler = new Compiler('dev');
+    await compiler.refreshGeneratedTypings();
+
+    const manifest = readProteumManifest(cli.paths.appRoot);
+    const errors = manifest.diagnostics.filter((diagnostic) => diagnostic.level === 'error');
+    const warnings = manifest.diagnostics.filter((diagnostic) => diagnostic.level === 'warning');
+
+    if (cli.args.json === true) {
+        console.log(
+            JSON.stringify(
+                {
+                    summary: {
+                        errors: errors.length,
+                        warnings: warnings.length,
+                        strictFailed: cli.args.strict === true && manifest.diagnostics.length > 0,
+                    },
+                    diagnostics: manifest.diagnostics,
+                },
+                null,
+                2,
+            ),
+        );
+    } else if (manifest.diagnostics.length === 0) {
+        console.log('Proteum doctor\n- No manifest diagnostics were found.');
+    } else {
+        console.log(
+            [
+                'Proteum doctor',
+                `- ${errors.length} errors`,
+                `- ${warnings.length} warnings`,
+                '',
+                renderGroup(manifest, errors, 'Errors'),
+                '',
+                renderGroup(manifest, warnings, 'Warnings'),
+            ].join('\n'),
+        );
+    }
+
+    if (cli.args.strict === true && manifest.diagnostics.length > 0) {
+        throw new Error(`Proteum doctor failed in strict mode with ${errors.length} errors and ${warnings.length} warnings.`);
+    }
+};

package/cli/commands/explain.ts

@@ -0,0 +1,226 @@
+import path from 'path';
+
+import cli from '..';
+import Compiler from '../compiler';
+import {
+    readProteumManifest,
+    type TProteumManifestDiagnostic,
+    type TProteumManifest,
+    type TProteumManifestController,
+    type TProteumManifestLayout,
+    type TProteumManifestRoute,
+    type TProteumManifestService,
+} from '../compiler/common/proteumManifest';
+
+const explainSectionNames = ['app', 'conventions', 'env', 'services', 'controllers', 'routes', 'layouts', 'diagnostics'] as const;
+const allowedExplainArgs = new Set(['json', 'all', ...explainSectionNames]);
+
+type TExplainSectionName = (typeof explainSectionNames)[number];
+
+const validateExplainArgs = () => {
+    const enabledArgs = Object.entries(cli.args)
+        .filter(([name, value]) => name !== 'workdir' && name !== 'verbose' && value === true)
+        .map(([name]) => name);
+
+    const invalidArgs = enabledArgs.filter((arg) => !allowedExplainArgs.has(arg));
+
+    if (invalidArgs.length > 0) {
+        throw new Error(
+            `Unknown explain argument(s): ${invalidArgs.join(', ')}. Allowed values: ${[...allowedExplainArgs].join(', ')}.`,
+        );
+    }
+};
+
+const getSelectedSections = (): TExplainSectionName[] => {
+    if (cli.args.all === true) return [...explainSectionNames];
+
+    return explainSectionNames.filter((sectionName) => cli.args[sectionName] === true);
+};
+
+const pickManifestSections = (manifest: TProteumManifest, sectionNames: TExplainSectionName[]) => {
+    if (sectionNames.length === 0) return manifest;
+
+    const selected: Record<string, unknown> = {};
+
+    for (const sectionName of sectionNames) {
+        selected[sectionName] = manifest[sectionName];
+    }
+
+    return selected;
+};
+
+const normalizePath = (value: string) => value.replace(/\\/g, '/');
+const formatLocation = (line?: number, column?: number) =>
+    line && column ? `:${line}:${column}` : line ? `:${line}` : '';
+
+const formatFilepath = (manifest: TProteumManifest, filepath: string) => {
+    const normalizedFilepath = normalizePath(filepath);
+    const normalizedAppRoot = normalizePath(manifest.app.root);
+    const normalizedCoreRoot = normalizePath(manifest.app.coreRoot);
+
+    if (normalizedFilepath === normalizedAppRoot) return '.';
+    if (normalizedFilepath.startsWith(normalizedAppRoot + '/'))
+        return normalizePath(path.relative(normalizedAppRoot, normalizedFilepath)) || '.';
+
+    if (normalizedFilepath === normalizedCoreRoot) return 'node_modules/proteum';
+    if (normalizedFilepath.startsWith(normalizedCoreRoot + '/'))
+        return normalizePath(path.join('node_modules/proteum', path.relative(normalizedCoreRoot, normalizedFilepath)));
+
+    return normalizedFilepath;
+};
+
+const formatService = (manifest: TProteumManifest, service: TProteumManifestService) => {
+    if (service.kind === 'ref') {
+        return `- ${service.registeredName} -> ref ${service.refTo} [${service.parent}]`;
+    }
+
+    const source = service.metasFilepath ? formatFilepath(manifest, service.metasFilepath) : 'unknown';
+    return `- ${service.registeredName} -> ${service.id} (${service.metaName}) [${service.scope}] priority=${service.priority} source=${source}`;
+};
+
+const formatController = (manifest: TProteumManifest, controller: TProteumManifestController) =>
+    `- ${controller.clientAccessor} -> POST ${controller.httpPath} [${controller.scope}] input=${controller.hasInput ? 'yes' : 'no'} source=${formatFilepath(manifest, controller.filepath)}${formatLocation(controller.sourceLocation.line, controller.sourceLocation.column)}#${controller.methodName}`;
+
+const formatRouteTarget = (route: TProteumManifestRoute) => {
+    if (route.kind === 'client-error') return route.code !== undefined ? String(route.code) : route.codeRaw || '?';
+    return route.path || route.pathRaw || '?';
+};
+
+const formatRoute = (manifest: TProteumManifest, route: TProteumManifestRoute) => {
+    const chunk = route.chunkId ? ` chunk=${route.chunkId}` : '';
+    const setup = route.hasSetup ? ' setup=yes' : ' setup=no';
+    const options = route.normalizedOptionKeys.length > 0 ? ` options=${route.normalizedOptionKeys.join(',')}` : '';
+    const resolution = route.targetResolution !== 'literal' ? ` resolution=${route.targetResolution}` : '';
+
+    return `- ${route.kind} ${route.methodName} ${formatRouteTarget(route)} [${route.scope}]${chunk}${setup}${options}${resolution} source=${formatFilepath(manifest, route.filepath)}${formatLocation(route.sourceLocation.line, route.sourceLocation.column)}`;
+};
+
+const formatLayout = (manifest: TProteumManifest, layout: TProteumManifestLayout) =>
+    `- ${layout.chunkId || 'root'} depth=${layout.depth} [${layout.scope}] source=${formatFilepath(manifest, layout.filepath)}`;
+
+const formatDiagnostic = (manifest: TProteumManifest, diagnostic: TProteumManifestDiagnostic) => {
+    const related =
+        diagnostic.relatedFilepaths && diagnostic.relatedFilepaths.length > 0
+            ? ` related=${diagnostic.relatedFilepaths.map((filepath) => formatFilepath(manifest, filepath)).join(',')}`
+            : '';
+
+    return `- [${diagnostic.level}] ${diagnostic.code} ${diagnostic.message} source=${formatFilepath(manifest, diagnostic.filepath)}${formatLocation(diagnostic.sourceLocation?.line, diagnostic.sourceLocation?.column)}${related}`;
+};
+
+const printSection = (title: string, lines: string[]) => {
+    if (lines.length === 0) return `${title}\n- none`;
+    return `${title}\n${lines.join('\n')}`;
+};
+
+const renderSummary = (manifest: TProteumManifest) => {
+    const errorsCount = manifest.diagnostics.filter((diagnostic) => diagnostic.level === 'error').length;
+    const warningsCount = manifest.diagnostics.filter((diagnostic) => diagnostic.level === 'warning').length;
+    const lines = [
+        `Proteum manifest: ${formatFilepath(manifest, path.join(manifest.app.root, '.proteum', 'manifest.json'))}`,
+        `App: ${manifest.app.identity.name} (${manifest.app.identity.identifier})`,
+        `Env keys: ${manifest.env.loadedTopLevelKeys.join(', ') || 'none'}`,
+        `Services: ${manifest.services.app.length} app, ${manifest.services.routerPlugins.length} router plugins`,
+        `Controllers: ${manifest.controllers.length}`,
+        `Routes: ${manifest.routes.client.length} client, ${manifest.routes.server.length} server`,
+        `Layouts: ${manifest.layouts.length}`,
+        `Diagnostics: ${errorsCount} errors, ${warningsCount} warnings`,
+        'Use `proteum explain --json` for the full machine-readable manifest or pass section flags like `routes` and `services`.',
+    ];
+
+    return lines.join('\n');
+};
+
+const renderHuman = (manifest: TProteumManifest, sectionNames: TExplainSectionName[]) => {
+    if (sectionNames.length === 0) return renderSummary(manifest);
+
+    const sections: string[] = [];
+
+    for (const sectionName of sectionNames) {
+        if (sectionName === 'app') {
+            sections.push(
+                printSection('App', [
+                    `- root=${formatFilepath(manifest, manifest.app.root)}`,
+                    `- coreRoot=${formatFilepath(manifest, manifest.app.coreRoot)}`,
+                    `- identity=${formatFilepath(manifest, manifest.app.identityFilepath)}`,
+                    `- name=${manifest.app.identity.name}`,
+                    `- identifier=${manifest.app.identity.identifier}`,
+                    `- title=${manifest.app.identity.fullTitle || manifest.app.identity.title || manifest.app.identity.name}`,
+                ]),
+            );
+            continue;
+        }
+
+        if (sectionName === 'conventions') {
+            sections.push(
+                printSection('Conventions', [
+                    `- routeSetupOptionKeys=${manifest.conventions.routeSetupOptionKeys.join(', ')}`,
+                    `- reservedRouteSetupKeys=${manifest.conventions.reservedRouteSetupKeys.join(', ')}`,
+                ]),
+            );
+            continue;
+        }
+
+        if (sectionName === 'env') {
+            sections.push(
+                printSection('Env', [
+                    `- source=${formatFilepath(manifest, manifest.env.sourceFilepath)}`,
+                    `- loadedTopLevelKeys=${manifest.env.loadedTopLevelKeys.join(', ') || 'none'}`,
+                    `- requiredTopLevelKeys=${manifest.env.requiredTopLevelKeys.join(', ')}`,
+                ]),
+            );
+            continue;
+        }
+
+        if (sectionName === 'services') {
+            sections.push(
+                printSection('App Services', manifest.services.app.map((service) => formatService(manifest, service))),
+                printSection(
+                    'Router Plugins',
+                    manifest.services.routerPlugins.map((service) => formatService(manifest, service)),
+                ),
+            );
+            continue;
+        }
+
+        if (sectionName === 'controllers') {
+            sections.push(printSection('Controllers', manifest.controllers.map((controller) => formatController(manifest, controller))));
+            continue;
+        }
+
+        if (sectionName === 'routes') {
+            sections.push(
+                printSection('Client Routes', manifest.routes.client.map((route) => formatRoute(manifest, route))),
+                printSection('Server Routes', manifest.routes.server.map((route) => formatRoute(manifest, route))),
+            );
+            continue;
+        }
+
+        if (sectionName === 'layouts') {
+            sections.push(printSection('Layouts', manifest.layouts.map((layout) => formatLayout(manifest, layout))));
+            continue;
+        }
+
+        if (sectionName === 'diagnostics') {
+            sections.push(printSection('Diagnostics', manifest.diagnostics.map((diagnostic) => formatDiagnostic(manifest, diagnostic))));
+        }
+    }
+
+    return sections.join('\n\n');
+};
+
+export const run = async (): Promise<void> => {
+    validateExplainArgs();
+
+    const compiler = new Compiler('dev');
+    await compiler.refreshGeneratedTypings();
+
+    const manifest = readProteumManifest(cli.paths.appRoot);
+    const selectedSections = getSelectedSections();
+
+    if (cli.args.json === true) {
+        console.log(JSON.stringify(pickManifestSections(manifest, selectedSections), null, 2));
+        return;
+    }
+
+    console.log(renderHuman(manifest, selectedSections));
+};

package/cli/commands/init.ts

@@ -8,6 +8,7 @@ import path from 'path';
 import prompts from 'prompts';
 import cmd from 'node-cmd';
 import replaceOnce from 'replace-once';
+import { UsageError } from 'clipanion';
 
 // Cor elibs
 import cli from '..';
@@ -19,73 +20,78 @@ const filesToConfig = ['package.json', 'identity.yaml'];
 /*----------------------------------
 - COMMANDE
 ----------------------------------*/
-export const run = () =>
-    new Promise<void>(async () => {
-        const config = await prompts([
-            {
-                type: 'text',
-                name: 'name',
-                message: 'Project name ?',
-                initial: 'MyProject',
-                validate: (value) =>
-                    /[a-z0-9\-\.]/i.test(value) || 'Must only include alphanumeric characters, and - . ',
-            },
-            {
-                type: 'text',
-                name: 'dirname',
-                message: 'Folder name ?',
-                initial: (value) => value.toLowerCase(),
-                validate: (value) =>
-                    /[a-z0-9\-\.]/.test(value) || 'Must only include lowercase alphanumeric characters, and - . ',
-            },
-            {
-                type: 'text',
-                name: 'description',
-                message: 'Briefly describe your project to your mom:',
-                initial: 'It will revolutionnize the world',
-                validate: (value) =>
-                    /[a-z0-9\-\. ]/i.test(value) || 'Must only include alphanumeric characters, and - . ',
-            },
-            { type: 'toggle', name: 'microservice', message: 'Separate API from the UI servers ?' },
-        ]);
-
-        const placeholders = {
-            PROJECT_NAME: config.name,
-            PACKAGE_NAME: config.name.toLowerCase(),
-            PROJECT_DESCRIPTION: config.description,
-        };
-
-        const paths = {
-            skeleton: path.join(cli.paths.core.cli, 'skeleton'),
-            project: path.join(process.cwd(), config.dirname),
-        };
-
-        // Copy skeleton to cwd/<project-name>
-        console.info('Creating project skeleton ...');
-        fs.copySync(paths.skeleton, paths.project);
-
-        // Sync framework-owned Codex assets into the new project.
-        ensureProjectAgentSymlinks({ appRoot: paths.project, coreRoot: cli.paths.core.root });
-
-        // Replace placeholders
-        console.info('Configuring project ...');
-        for (const file of filesToConfig) {
-            console.log('- ' + file);
-
-            const filepath = path.join(paths.project, file);
-            const content = fs.readFileSync(filepath, 'utf-8');
-
-            const placeholders_keys = Object.keys(placeholders).map((k) => '{{ ' + k + ' }}');
-            const values = Object.values(placeholders);
-
-            fs.writeFileSync(filepath, replaceOnce(content, placeholders_keys, values));
-        }
-
-        // Npm install
-        console.info('Installing packages ...');
-        cmd.runSync(`cd "${paths.project}" && npm i`);
-
-        // Run demo app
-        /*console.info("Run demo ...");
-    await cli.shell('5htp dev');*/
-    });
+export const run = async (): Promise<void> => {
+    const skeletonPath = path.join(cli.paths.core.cli, 'skeleton');
+
+    if (!fs.existsSync(skeletonPath)) {
+        throw new UsageError(
+            'Proteum init is unavailable in this checkout because `cli/skeleton` is missing. Restore the scaffold assets or use an installed Proteum package that includes them.',
+        );
+    }
+
+    const config = await prompts([
+        {
+            type: 'text',
+            name: 'name',
+            message: 'Project name ?',
+            initial: 'MyProject',
+            validate: (value) => /[a-z0-9\-\.]/i.test(value) || 'Must only include alphanumeric characters, and - . ',
+        },
+        {
+            type: 'text',
+            name: 'dirname',
+            message: 'Folder name ?',
+            initial: (value) => value.toLowerCase(),
+            validate: (value) =>
+                /[a-z0-9\-\.]/.test(value) || 'Must only include lowercase alphanumeric characters, and - . ',
+        },
+        {
+            type: 'text',
+            name: 'description',
+            message: 'Briefly describe your project to your mom:',
+            initial: 'It will revolutionnize the world',
+            validate: (value) => /[a-z0-9\-\. ]/i.test(value) || 'Must only include alphanumeric characters, and - . ',
+        },
+        { type: 'toggle', name: 'microservice', message: 'Separate API from the UI servers ?' },
+    ]);
+
+    const placeholders = {
+        PROJECT_NAME: config.name,
+        PACKAGE_NAME: config.name.toLowerCase(),
+        PROJECT_DESCRIPTION: config.description,
+    };
+
+    const paths = {
+        skeleton: skeletonPath,
+        project: path.join(process.cwd(), config.dirname),
+    };
+
+    // Copy skeleton to cwd/<project-name>
+    console.info('Creating project skeleton ...');
+    fs.copySync(paths.skeleton, paths.project);
+
+    // Sync framework-owned Codex assets into the new project.
+    ensureProjectAgentSymlinks({ appRoot: paths.project, coreRoot: cli.paths.core.root });
+
+    // Replace placeholders
+    console.info('Configuring project ...');
+    for (const file of filesToConfig) {
+        console.log('- ' + file);
+
+        const filepath = path.join(paths.project, file);
+        const content = fs.readFileSync(filepath, 'utf-8');
+
+        const placeholders_keys = Object.keys(placeholders).map((k) => '{{ ' + k + ' }}');
+        const values = Object.values(placeholders);
+
+        fs.writeFileSync(filepath, replaceOnce(content, placeholders_keys, values));
+    }
+
+    // Npm install
+    console.info('Installing packages ...');
+    cmd.runSync(`cd "${paths.project}" && npm i`);
+
+    // Run demo app
+    /*console.info("Run demo ...");
+await cli.shell('5htp dev');*/
+};

package/cli/commands/lint.ts

@@ -1,11 +1,13 @@
 import cli from '..';
 import { runAppLint } from '../utils/check';
+import { renderRows } from '../presentation/layout';
+import { renderStep, renderSuccess, renderTitle } from '../presentation/ink';
 
 const allowedLintArgs = new Set(['fix']);
 
 const validateLintArgs = () => {
     const enabledArgs = Object.entries(cli.args)
-        .filter(([name, value]) => name !== 'workdir' && value === true)
+        .filter(([name, value]) => name !== 'workdir' && name !== 'verbose' && value === true)
         .map(([name]) => name);
 
     const invalidArgs = enabledArgs.filter((arg) => !allowedLintArgs.has(arg));
@@ -17,5 +19,20 @@ const validateLintArgs = () => {
 export const run = async (): Promise<void> => {
     validateLintArgs();
 
+    console.info(
+        [
+            await renderTitle(
+                'PROTEUM LINT',
+                cli.args.fix === true ? 'Running ESLint with fix mode enabled.' : 'Running ESLint in check mode.',
+            ),
+            renderRows([
+                { label: 'app', value: cli.paths.appRoot === process.cwd() ? '.' : cli.paths.appRoot },
+                { label: 'fix', value: cli.args.fix === true ? 'enabled' : 'disabled' },
+            ]),
+            await renderStep('[1/1]', cli.args.fix === true ? 'Applying fixable ESLint changes.' : 'Checking ESLint rules.'),
+        ].join('\n\n'),
+    );
+
     await runAppLint({ fix: cli.args.fix === true });
+    console.info(await renderSuccess(cli.args.fix === true ? 'Lint fixes applied.' : 'Lint passed.'));
 };

package/cli/commands/refresh.ts

@@ -4,15 +4,25 @@
 
 // Configs
 import Compiler from '../compiler';
+import cli from '..';
+import { renderRows } from '../presentation/layout';
+import { renderStep, renderSuccess, renderTitle } from '../presentation/ink';
 
 /*----------------------------------
 - COMMAND
 ----------------------------------*/
-export const run = (): Promise<void> =>
-    new Promise(async (resolve) => {
-        const compiler = new Compiler('dev');
+export const run = async (): Promise<void> => {
+    const compiler = new Compiler('dev');
 
-        await compiler.refreshGeneratedTypings();
+    console.info(
+        [
+            await renderTitle('PROTEUM REFRESH', 'Regenerating framework-owned contracts and typings.'),
+            renderRows([{ label: 'app', value: cli.paths.appRoot === process.cwd() ? '.' : cli.paths.appRoot }]),
+            await renderStep('[1/1]', 'Refreshing `.proteum` artifacts and generated typings.'),
+        ].join('\n\n'),
+    );
 
-        resolve();
-    });
+    await compiler.refreshGeneratedTypings();
+
+    console.info(await renderSuccess('Generated artifacts and typings are up to date.'));
+};

package/cli/commands/typecheck.ts

@@ -1,8 +1,12 @@
 import cli from '..';
 import { refreshGeneratedTypings, runAppTypecheck } from '../utils/check';
+import { renderRows } from '../presentation/layout';
+import { renderStep, renderSuccess, renderTitle } from '../presentation/ink';
 
 const validateTypecheckArgs = () => {
-    const enabledArgs = Object.entries(cli.args).filter(([name, value]) => name !== 'workdir' && value === true);
+    const enabledArgs = Object.entries(cli.args).filter(
+        ([name, value]) => name !== 'workdir' && name !== 'verbose' && value === true,
+    );
 
     if (enabledArgs.length > 0)
         throw new Error(
@@ -13,6 +17,15 @@ const validateTypecheckArgs = () => {
 export const run = async (): Promise<void> => {
     validateTypecheckArgs();
 
+    console.info(
+        [
+            await renderTitle('PROTEUM TYPECHECK', 'Refreshing generated contracts, then running TypeScript.'),
+            renderRows([{ label: 'app', value: cli.paths.appRoot === process.cwd() ? '.' : cli.paths.appRoot }]),
+        ].join('\n\n'),
+    );
+    console.info(await renderStep('[1/2]', 'Refreshing generated typings.'));
     await refreshGeneratedTypings();
+    console.info(await renderStep('[2/2]', 'Running TypeScript typechecking.'));
     await runAppTypecheck();
+    console.info(await renderSuccess('Typecheck passed.'));
 };