@tanstack/cta-engine 0.14.3 → 0.15.0

package/dist/file-helpers.js

@@ -0,0 +1,165 @@
+import { readdir } from 'node:fs/promises';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { basename, extname, resolve } from 'node:path';
+import parseGitignore from 'parse-gitignore';
+import ignore from 'ignore';
+const BINARY_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico'];
+export function readFileHelper(path) {
+    if (isBinaryFile(path)) {
+        return `base64::${readFileSync(path).toString('base64')}`;
+    }
+    else {
+        return readFileSync(path, 'utf-8').toString();
+    }
+}
+export function isBinaryFile(path) {
+    return BINARY_EXTENSIONS.includes(extname(path));
+}
+export function convertBinaryContentsToBase64(contents) {
+    return `base64::${Buffer.from(contents).toString('base64')}`;
+}
+export function isBase64(content) {
+    return content.startsWith('base64::');
+}
+export function getBinaryFile(content) {
+    if (content.startsWith('base64::')) {
+        const binaryContent = Buffer.from(content.replace('base64::', ''), 'base64');
+        return binaryContent;
+    }
+    return null;
+}
+export function relativePath(from, to) {
+    const cleanedFrom = from.startsWith('./') ? from.slice(2) : from;
+    const cleanedTo = to.startsWith('./') ? to.slice(2) : to;
+    const fromSegments = cleanedFrom.split('/');
+    const toSegments = cleanedTo.split('/');
+    fromSegments.pop();
+    toSegments.pop();
+    let commonIndex = 0;
+    while (commonIndex < fromSegments.length &&
+        commonIndex < toSegments.length &&
+        fromSegments[commonIndex] === toSegments[commonIndex]) {
+        commonIndex++;
+    }
+    const upLevels = fromSegments.length - commonIndex;
+    const downLevels = toSegments.slice(commonIndex);
+    if (upLevels === 0 && downLevels.length === 0) {
+        return `./${basename(to)}`;
+    }
+    else if (upLevels === 0 && downLevels.length > 0) {
+        return `./${downLevels.join('/')}/${basename(to)}`;
+    }
+    else {
+        const relativePath = [...Array(upLevels).fill('..'), ...downLevels].join('/');
+        return `${relativePath}/${basename(to)}`;
+    }
+}
+export function isDirectory(path) {
+    return statSync(path).isDirectory();
+}
+export function findFilesRecursively(path, files) {
+    const dirFiles = readdirSync(path);
+    for (const file of dirFiles) {
+        const filePath = resolve(path, file);
+        if (isDirectory(filePath)) {
+            findFilesRecursively(filePath, files);
+        }
+        else {
+            files[filePath] = readFileHelper(filePath);
+        }
+    }
+}
+async function recursivelyGatherFilesHelper(basePath, path, files, ignore) {
+    const dirFiles = await readdir(path, { withFileTypes: true });
+    for (const file of dirFiles) {
+        if (ignore(file.name)) {
+            continue;
+        }
+        if (file.isDirectory()) {
+            await recursivelyGatherFilesHelper(basePath, resolve(path, file.name), files, ignore);
+        }
+        else {
+            const filePath = resolve(path, file.name);
+            files[filePath.replace(basePath, '.')] = await readFileHelper(filePath);
+        }
+    }
+}
+export async function recursivelyGatherFiles(path, includeProjectFiles = true) {
+    const ignore = createIgnore(path, includeProjectFiles);
+    const files = {};
+    await recursivelyGatherFilesHelper(path, path, files, ignore);
+    return files;
+}
+async function recursivelyGatherFilesFromEnvironmentHelper(environment, basePath, path, files, ignore) {
+    const dirFiles = await environment.readdir(path);
+    for (const file of dirFiles) {
+        if (ignore(file)) {
+            continue;
+        }
+        if (environment.isDirectory(resolve(path, file))) {
+            await recursivelyGatherFilesFromEnvironmentHelper(environment, basePath, resolve(path, file), files, ignore);
+        }
+        else {
+            const filePath = resolve(path, file);
+            files[filePath.replace(basePath, '.')] =
+                await environment.readFile(filePath);
+        }
+    }
+}
+export async function recursivelyGatherFilesFromEnvironment(environment, path, includeProjectFiles = true) {
+    const ignore = createIgnore(path, includeProjectFiles);
+    const files = {};
+    await recursivelyGatherFilesFromEnvironmentHelper(environment, path, path, files, ignore);
+    return files;
+}
+export const IGNORE_FILES = [
+    '.starter',
+    '.add-on',
+    '.cta.json',
+    '.git',
+    'add-on-info.json',
+    'add-on.json',
+    'build',
+    'bun.lock',
+    'bun.lockb',
+    'deno.lock',
+    'dist',
+    'node_modules',
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'starter.json',
+    'starter-info.json',
+    'yarn.lock',
+];
+const PROJECT_FILES = ['package.json'];
+export function createIgnore(path, includeProjectFiles = true) {
+    const ignoreList = existsSync(resolve(path, '.gitignore'))
+        ? parseGitignore(readFileSync(resolve(path, '.gitignore'))).patterns
+        : [];
+    const ig = ignore().add(ignoreList);
+    return (filePath) => {
+        const fileName = basename(filePath);
+        if (IGNORE_FILES.includes(fileName) ||
+            (includeProjectFiles && PROJECT_FILES.includes(fileName))) {
+            return true;
+        }
+        const nameWithoutDotSlash = fileName.replace(/^\.\//, '');
+        return ig.ignores(nameWithoutDotSlash);
+    };
+}
+export function cleanUpFiles(files, targetDir) {
+    return Object.keys(files).reduce((acc, file) => {
+        if (basename(file) !== '.cta.json') {
+            acc[targetDir ? file.replace(targetDir, '.') : file] = files[file];
+        }
+        return acc;
+    }, {});
+}
+export function cleanUpFileArray(files, targetDir) {
+    return files.reduce((acc, file) => {
+        if (basename(file) !== '.cta.json') {
+            acc.push(targetDir ? file.replace(targetDir, '.') : file);
+        }
+        return acc;
+    }, []);
+}

package/dist/frameworks.js

@@ -0,0 +1,92 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { findFilesRecursively, isDirectory, readFileHelper, } from './file-helpers.js';
+const frameworks = [];
+function getAddOns(framework) {
+    const addOns = [];
+    for (const addOnsBase of framework.addOnsDirectories) {
+        for (const dir of readdirSync(addOnsBase).filter((file) => isDirectory(resolve(addOnsBase, file)))) {
+            const filePath = resolve(addOnsBase, dir, 'info.json');
+            const fileContent = readFileSync(filePath, 'utf-8');
+            const info = JSON.parse(fileContent);
+            let packageAdditions = {};
+            if (existsSync(resolve(addOnsBase, dir, 'package.json'))) {
+                packageAdditions = JSON.parse(readFileSync(resolve(addOnsBase, dir, 'package.json'), 'utf-8'));
+            }
+            let readme;
+            if (existsSync(resolve(addOnsBase, dir, 'README.md'))) {
+                readme = readFileSync(resolve(addOnsBase, dir, 'README.md'), 'utf-8');
+            }
+            let smallLogo;
+            if (existsSync(resolve(addOnsBase, dir, 'small-logo.svg'))) {
+                smallLogo = readFileSync(resolve(addOnsBase, dir, 'small-logo.svg'), 'utf-8');
+            }
+            const absoluteFiles = {};
+            const assetsDir = resolve(addOnsBase, dir, 'assets');
+            if (existsSync(assetsDir)) {
+                findFilesRecursively(assetsDir, absoluteFiles);
+            }
+            const files = {};
+            for (const file of Object.keys(absoluteFiles)) {
+                files[file.replace(assetsDir, '.')] = readFileHelper(file);
+            }
+            const getFiles = () => {
+                return Promise.resolve(Object.keys(files));
+            };
+            const getFileContents = (path) => {
+                return Promise.resolve(files[path]);
+            };
+            addOns.push({
+                ...info,
+                id: dir,
+                packageAdditions,
+                readme,
+                files,
+                smallLogo,
+                getFiles,
+                getFileContents,
+                getDeletedFiles: () => Promise.resolve(info.deletedFiles ?? []),
+            });
+        }
+    }
+    return addOns;
+}
+export function __testRegisterFramework(framework) {
+    frameworks.push(framework);
+}
+export function __testClearFrameworks() {
+    frameworks.length = 0;
+}
+export function registerFramework(framework) {
+    const baseAssetsDirectory = resolve(framework.baseDirectory, 'base');
+    const basePackageJSON = JSON.parse(readFileSync(resolve(baseAssetsDirectory, 'package.json'), 'utf8'));
+    const optionalPackages = JSON.parse(readFileSync(resolve(framework.baseDirectory, 'packages.json'), 'utf8'));
+    const addOns = getAddOns(framework);
+    const frameworkWithBundler = {
+        ...framework,
+        getFiles: () => {
+            const files = {};
+            findFilesRecursively(baseAssetsDirectory, files);
+            return Promise.resolve(Object.keys(files).map((path) => path.replace(baseAssetsDirectory, '.')));
+        },
+        getFileContents: (path) => {
+            return Promise.resolve(readFileHelper(resolve(baseAssetsDirectory, path)));
+        },
+        getDeletedFiles: () => {
+            return Promise.resolve([]);
+        },
+        basePackageJSON,
+        optionalPackages,
+        getAddOns: () => addOns,
+    };
+    frameworks.push(frameworkWithBundler);
+}
+export function getFrameworkById(id) {
+    return frameworks.find((framework) => framework.id === id);
+}
+export function getFrameworkByName(name) {
+    return frameworks.find((framework) => framework.name === name);
+}
+export function getFrameworks() {
+    return frameworks;
+}

package/dist/index.js

@@ -1 +1,18 @@
-export { cli } from './cli.js';
+export { createApp } from './create-app.js';
+export { addToApp } from './add-to-app.js';
+export { finalizeAddOns, getAllAddOns } from './add-ons.js';
+export { loadRemoteAddOn } from './custom-add-ons/add-on.js';
+export { loadStarter } from './custom-add-ons/starter.js';
+export { createMemoryEnvironment, createDefaultEnvironment, } from './environment.js';
+export { CODE_ROUTER, CONFIG_FILE, FILE_ROUTER } from './constants.js';
+export { DEFAULT_PACKAGE_MANAGER, SUPPORTED_PACKAGE_MANAGERS, getPackageManager, } from './package-manager.js';
+export { registerFramework, getFrameworkById, getFrameworkByName, getFrameworks, } from './frameworks.js';
+export { writeConfigFileToEnvironment, readConfigFileFromEnvironment, readConfigFile, } from './config-file.js';
+export { cleanUpFiles, cleanUpFileArray, readFileHelper, getBinaryFile, recursivelyGatherFiles, relativePath, } from './file-helpers.js';
+export { formatCommand } from './utils.js';
+export { initStarter, compileStarter } from './custom-add-ons/starter.js';
+export { initAddOn, compileAddOn } from './custom-add-ons/add-on.js';
+export { createAppOptionsFromPersisted, createSerializedOptionsFromPersisted, } from './custom-add-ons/shared.js';
+export { createSerializedOptions } from './options.js';
+export { getRawRegistry, getRegistry, getRegistryAddOns, getRegistryStarters, } from './registry.js';
+export { StarterCompiledSchema, AddOnCompiledSchema, AddOnInfoSchema, IntegrationSchema, } from './types.js';

package/dist/integrations/git.js

@@ -0,0 +1,4 @@
+import { resolve } from 'node:path';
+export async function setupGit(environment, targetDir) {
+    await environment.execute('git', ['init'], resolve(targetDir));
+}

package/dist/integrations/shadcn.js

@@ -0,0 +1,33 @@
+import { resolve } from 'node:path';
+import { packageManagerExecute } from '../package-manager.js';
+export async function installShadcnComponents(environment, targetDir, options) {
+    const s = environment.spinner();
+    if (options.chosenAddOns.find((a) => a.id === 'shadcn')) {
+        const shadcnComponents = new Set();
+        for (const addOn of options.chosenAddOns) {
+            if (addOn.shadcnComponents) {
+                for (const component of addOn.shadcnComponents) {
+                    shadcnComponents.add(component);
+                }
+            }
+        }
+        if (options.starter) {
+            if (options.starter.shadcnComponents) {
+                for (const component of options.starter.shadcnComponents) {
+                    shadcnComponents.add(component);
+                }
+            }
+        }
+        if (shadcnComponents.size > 0) {
+            s.start(`Installing shadcn components (${Array.from(shadcnComponents).join(', ')})...`);
+            environment.startStep({
+                id: 'install-shadcn-components',
+                type: 'command',
+                message: `Installing shadcn components (${Array.from(shadcnComponents).join(', ')})...`,
+            });
+            await packageManagerExecute(environment, resolve(targetDir), options.packageManager, 'shadcn@latest', ['add', '--silent', '--yes', ...Array.from(shadcnComponents)]);
+            environment.finishStep('install-shadcn-components', 'Shadcn components installed');
+            s.stop(`Installed additional shadcn components`);
+        }
+    }
+}

package/dist/options.js

@@ -1,333 +1,9 @@
-import { cancel, confirm, isCancel, multiselect, select, text, } from '@clack/prompts';
-import { DEFAULT_PACKAGE_MANAGER, SUPPORTED_PACKAGE_MANAGERS, getPackageManager, } from './package-manager.js';
-import { DEFAULT_TOOLCHAIN, SUPPORTED_TOOLCHAINS } from './toolchain.js';
-import { CODE_ROUTER, DEFAULT_FRAMEWORK, FILE_ROUTER } from './constants.js';
-import { finalizeAddOns, getAllAddOns, loadRemoteAddOn } from './add-ons.js';
-// If all CLI options are provided, use them directly
-export async function normalizeOptions(cliOptions, forcedMode, forcedAddOns) {
-    // in some cases, if you use windows/powershell, the argument for addons
-    // if sepparated by comma is not really passed as an array, but as a string
-    // with spaces, We need to normalize this edge case.
-    if (Array.isArray(cliOptions.addOns) && cliOptions.addOns.length === 1) {
-        const parseSeparatedArgs = cliOptions.addOns[0].split(' ');
-        if (parseSeparatedArgs.length > 1) {
-            cliOptions.addOns = parseSeparatedArgs;
-        }
-    }
-    if (cliOptions.projectName) {
-        let typescript = cliOptions.template === 'typescript' ||
-            cliOptions.template === 'file-router' ||
-            cliOptions.framework === 'solid';
-        let tailwind = !!cliOptions.tailwind;
-        if (cliOptions.framework === 'solid') {
-            tailwind = true;
-        }
-        let mode = cliOptions.template === 'file-router' ? FILE_ROUTER : CODE_ROUTER;
-        const overlay = cliOptions.overlay
-            ? (await loadRemoteAddOn(cliOptions.overlay))
-            : undefined;
-        if (overlay) {
-            tailwind = overlay.tailwind;
-            typescript = overlay.typescript;
-            cliOptions.framework = overlay.framework;
-            mode = overlay.mode;
-        }
-        let addOns = false;
-        let chosenAddOns = [];
-        if (Array.isArray(cliOptions.addOns) ||
-            overlay?.dependsOn ||
-            forcedAddOns) {
-            addOns = true;
-            let finalAddOns = Array.from(new Set([...(overlay?.dependsOn || []), ...(forcedAddOns || [])]));
-            if (cliOptions.addOns && Array.isArray(cliOptions.addOns)) {
-                finalAddOns = Array.from(new Set([
-                    ...(forcedAddOns || []),
-                    ...finalAddOns,
-                    ...cliOptions.addOns,
-                ]));
-            }
-            chosenAddOns = await finalizeAddOns(cliOptions.framework || DEFAULT_FRAMEWORK, forcedMode || cliOptions.template === 'file-router'
-                ? FILE_ROUTER
-                : CODE_ROUTER, finalAddOns);
-            tailwind = true;
-            typescript = true;
-        }
-        return {
-            framework: cliOptions.framework || 'react',
-            projectName: cliOptions.projectName,
-            typescript,
-            tailwind,
-            packageManager: cliOptions.packageManager ||
-                getPackageManager() ||
-                DEFAULT_PACKAGE_MANAGER,
-            toolchain: cliOptions.toolchain || DEFAULT_TOOLCHAIN,
-            mode,
-            git: !!cliOptions.git,
-            addOns,
-            chosenAddOns,
-            variableValues: {},
-            overlay,
-        };
-    }
-}
-async function collectVariables(variables) {
-    const responses = {};
-    for (const variable of variables) {
-        if (variable.type === 'string') {
-            const response = await text({
-                message: variable.description,
-                initialValue: variable.default,
-            });
-            if (isCancel(response)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            responses[variable.name] = response;
-        }
-        else if (variable.type === 'number') {
-            const response = await text({
-                message: variable.description,
-                initialValue: variable.default.toString(),
-            });
-            if (isCancel(response)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            responses[variable.name] = Number(response);
-        }
-        else {
-            const response = await confirm({
-                message: variable.description,
-                initialValue: variable.default === true,
-            });
-            if (isCancel(response)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            responses[variable.name] = response;
-        }
-    }
-    return responses;
-}
-export async function promptForOptions(cliOptions, { forcedAddOns = [], forcedMode, }) {
-    const options = {};
-    options.framework = cliOptions.framework || DEFAULT_FRAMEWORK;
-    if (options.framework === 'solid') {
-        options.typescript = true;
-        options.tailwind = true;
-    }
-    if (cliOptions.addOns) {
-        options.typescript = true;
-    }
-    if (!cliOptions.projectName) {
-        const value = await text({
-            message: 'What would you like to name your project?',
-            defaultValue: 'my-app',
-            validate(value) {
-                if (!value) {
-                    return 'Please enter a name';
-                }
-            },
-        });
-        if (isCancel(value)) {
-            cancel('Operation cancelled.');
-            process.exit(0);
-        }
-        options.projectName = value;
-    }
-    else {
-        options.projectName = cliOptions.projectName;
-    }
-    // Router type selection
-    if (!cliOptions.template && !forcedMode) {
-        const routerType = await select({
-            message: 'Select the router type:',
-            options: [
-                {
-                    value: FILE_ROUTER,
-                    label: 'File Router - File-based routing structure',
-                },
-                {
-                    value: CODE_ROUTER,
-                    label: 'Code Router - Traditional code-based routing',
-                },
-            ],
-            initialValue: FILE_ROUTER,
-        });
-        if (isCancel(routerType)) {
-            cancel('Operation cancelled.');
-            process.exit(0);
-        }
-        options.mode = routerType;
-    }
-    else if (forcedMode) {
-        options.mode = forcedMode === 'file-router' ? FILE_ROUTER : CODE_ROUTER;
-        options.typescript = options.mode === FILE_ROUTER;
-    }
-    else {
-        options.mode =
-            cliOptions.template === 'file-router' ? FILE_ROUTER : CODE_ROUTER;
-        if (options.mode === FILE_ROUTER) {
-            options.typescript = true;
-        }
-    }
-    // TypeScript selection (if using Code Router)
-    if (!options.typescript) {
-        if (options.mode === CODE_ROUTER) {
-            const typescriptEnable = await confirm({
-                message: 'Would you like to use TypeScript?',
-                initialValue: true,
-            });
-            if (isCancel(typescriptEnable)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            options.typescript = typescriptEnable;
-        }
-        else {
-            options.typescript = true;
-        }
-    }
-    // Tailwind selection
-    if (!cliOptions.tailwind && options.framework === 'react') {
-        const tailwind = await confirm({
-            message: 'Would you like to use Tailwind CSS?',
-            initialValue: true,
-        });
-        if (isCancel(tailwind)) {
-            cancel('Operation cancelled.');
-            process.exit(0);
-        }
-        options.tailwind = tailwind;
-    }
-    else {
-        options.tailwind = options.framework === 'solid' || !!cliOptions.tailwind;
-    }
-    // Package manager selection
-    if (cliOptions.packageManager === undefined) {
-        const detectedPackageManager = getPackageManager();
-        if (!detectedPackageManager) {
-            const pm = await select({
-                message: 'Select package manager:',
-                options: SUPPORTED_PACKAGE_MANAGERS.map((pm) => ({
-                    value: pm,
-                    label: pm,
-                })),
-                initialValue: DEFAULT_PACKAGE_MANAGER,
-            });
-            if (isCancel(pm)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            options.packageManager = pm;
-        }
-        else {
-            options.packageManager = detectedPackageManager;
-        }
-    }
-    else {
-        options.packageManager = cliOptions.packageManager;
-    }
-    // Toolchain selection
-    if (cliOptions.toolchain === undefined) {
-        const tc = await select({
-            message: 'Select toolchain',
-            options: SUPPORTED_TOOLCHAINS.map((tc) => ({
-                value: tc,
-                label: tc,
-            })),
-            initialValue: DEFAULT_TOOLCHAIN,
-        });
-        if (isCancel(tc)) {
-            cancel('Operation cancelled.');
-            process.exit(0);
-        }
-        options.toolchain = tc;
-    }
-    else {
-        options.toolchain = cliOptions.toolchain;
-    }
-    options.chosenAddOns = [];
-    if (Array.isArray(cliOptions.addOns)) {
-        options.chosenAddOns = await finalizeAddOns(options.framework, options.mode, Array.from(new Set([...cliOptions.addOns, ...forcedAddOns])));
-        options.tailwind = true;
-    }
-    else if (cliOptions.addOns) {
-        // Select any add-ons
-        const allAddOns = await getAllAddOns(options.framework, options.mode);
-        const addOns = allAddOns.filter((addOn) => addOn.type === 'add-on');
-        let selectedAddOns = [];
-        if (options.typescript && addOns.length > 0) {
-            const value = await multiselect({
-                message: 'What add-ons would you like for your project:',
-                options: addOns
-                    .filter((addOn) => !forcedAddOns.includes(addOn.id))
-                    .map((addOn) => ({
-                    value: addOn.id,
-                    label: addOn.name,
-                    hint: addOn.description,
-                })),
-                required: false,
-            });
-            if (isCancel(value)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            selectedAddOns = value;
-        }
-        // Select any examples
-        let selectedExamples = [];
-        const examples = allAddOns.filter((addOn) => addOn.type === 'example');
-        if (options.typescript && examples.length > 0) {
-            const value = await multiselect({
-                message: 'Would you like any examples?',
-                options: examples
-                    .filter((addOn) => !forcedAddOns.includes(addOn.id))
-                    .map((addOn) => ({
-                    value: addOn.id,
-                    label: addOn.name,
-                    hint: addOn.description,
-                })),
-                required: false,
-            });
-            if (isCancel(value)) {
-                cancel('Operation cancelled.');
-                process.exit(0);
-            }
-            selectedExamples = value;
-        }
-        if (selectedAddOns.length > 0 ||
-            selectedExamples.length > 0 ||
-            forcedAddOns.length > 0) {
-            options.chosenAddOns = await finalizeAddOns(options.framework, options.mode, Array.from(new Set([...selectedAddOns, ...selectedExamples, ...forcedAddOns])));
-            options.tailwind = true;
-        }
-    }
-    else if (forcedAddOns.length > 0) {
-        options.chosenAddOns = await finalizeAddOns(options.framework, options.mode, forcedAddOns);
-    }
-    // Collect variables
-    const variables = [];
-    for (const addOn of options.chosenAddOns) {
-        for (const variable of addOn.variables ?? []) {
-            variables.push(variable);
-        }
-    }
-    options.variableValues = await collectVariables(variables);
-    // Git selection
-    if (cliOptions.git === undefined) {
-        const git = await confirm({
-            message: 'Would you like to initialize a new git repository?',
-            initialValue: true,
-        });
-        if (isCancel(git)) {
-            cancel('Operation cancelled.');
-            process.exit(0);
-        }
-        options.git = git;
-    }
-    else {
-        options.git = !!cliOptions.git;
-    }
-    return options;
-}
+export const createSerializedOptions = (options) => {
+    const serializedOptions = {
+        ...options,
+        chosenAddOns: options.chosenAddOns.map((addOn) => addOn.id),
+        framework: options.framework.id,
+        starter: options.starter?.id,
+    };
+    return serializedOptions;
+};