@modern-js/core 0.0.0-windows-20211056953 → 0.0.3-20221226

package/dist/load-configs/index.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = exports.getConfigFilePath = exports.clearFilesOverTime = exports.getDependencies = exports.getPackageConfig = exports.PACKAGE_JSON_CONFIG_NAME = exports.CONFIG_FILE_NAME = void 0;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@modern-js/utils");
+const node_bundle_require_1 = require("@modern-js/node-bundle-require");
+const debug = (0, utils_1.createDebugger)('load-config');
+exports.CONFIG_FILE_NAME = 'modern.config';
+exports.PACKAGE_JSON_CONFIG_NAME = 'modernConfig';
+/**
+ * Get user config from package.json.
+ * @param appDirectory - App root directory.
+ * @returns modernConfig or undefined
+ */
+const getPackageConfig = (appDirectory, packageJsonConfig) => {
+    const json = JSON.parse(utils_1.fs.readFileSync(path_1.default.resolve(appDirectory, './package.json'), 'utf8'));
+    return json[packageJsonConfig !== null && packageJsonConfig !== void 0 ? packageJsonConfig : exports.PACKAGE_JSON_CONFIG_NAME];
+};
+exports.getPackageConfig = getPackageConfig;
+/**
+ * Get the file dependencies by module.children, ignore file path in node_modules and this monorepo packages default.
+ * @param filePath - Absolute file path.
+ * @returns File dependencies array.
+ */
+const getDependencies = (filePath) => {
+    const mod = require.cache[filePath];
+    if (!mod) {
+        debug(`${filePath} has not been required yet`);
+        return [];
+    }
+    const deps = [];
+    if (!/\/node_modules\/|\/modern-js\/packages\//.test(mod.id)) {
+        deps.push(mod.id);
+        for (const child of mod.children) {
+            deps.push(...(0, exports.getDependencies)(child.id));
+        }
+    }
+    return deps;
+};
+exports.getDependencies = getDependencies;
+/**
+ *
+ * @param targetDir target dir
+ * @param overtime Unit of second
+ */
+const clearFilesOverTime = async (targetDir, overtime) => {
+    // when stats is true, globby return Stats[]
+    const files = (await (0, utils_1.globby)(`${targetDir}/**/*`, {
+        stats: true,
+        absolute: true,
+    }));
+    const currentTime = Date.now();
+    if (files.length > 0) {
+        for (const file of files) {
+            if (currentTime - file.stats.birthtimeMs >= overtime * 1000) {
+                utils_1.fs.unlinkSync(file.path);
+            }
+        }
+    }
+};
+exports.clearFilesOverTime = clearFilesOverTime;
+const bundleRequireWithCatch = async (configFile, { appDirectory }) => {
+    try {
+        const mod = await (0, node_bundle_require_1.bundleRequire)(configFile, {
+            autoClear: false,
+            getOutputFile: async (filePath) => {
+                const defaultOutputFileName = path_1.default.basename(await (0, node_bundle_require_1.defaultGetOutputFile)(filePath));
+                const outputPath = path_1.default.join(appDirectory, utils_1.CONFIG_CACHE_DIR);
+                // 10 min
+                const timeLimit = 10 * 60;
+                await (0, exports.clearFilesOverTime)(outputPath, timeLimit);
+                return path_1.default.join(outputPath, defaultOutputFileName);
+            },
+        });
+        return mod;
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            e.message = `Get Error while loading config file: ${configFile}, please check it and retry.\n${e.message || ''}`;
+        }
+        throw e;
+    }
+};
+const getConfigFilePath = (appDirectory, filePath) => {
+    if (filePath) {
+        if (path_1.default.isAbsolute(filePath)) {
+            return filePath;
+        }
+        return path_1.default.resolve(appDirectory, filePath);
+    }
+    return (0, utils_1.findExists)(utils_1.CONFIG_FILE_EXTENSIONS.map(extension => path_1.default.resolve(appDirectory, `${exports.CONFIG_FILE_NAME}${extension}`)));
+};
+exports.getConfigFilePath = getConfigFilePath;
+/**
+ * Parse and load user config file, support extensions like .ts, mjs, js, ejs.
+ * @param appDirectory - App root directory, from which start search user config file.
+ * @param filePath - Specific absolute config file path.
+ * @returns Object contain config file path, user config object and dependency files used by config file.
+ */
+const loadConfig = async (appDirectory, filePath, packageJsonConfig) => {
+    const configFile = (0, exports.getConfigFilePath)(appDirectory, filePath);
+    const pkgConfig = (0, exports.getPackageConfig)(appDirectory, packageJsonConfig);
+    let config;
+    const dependencies = pkgConfig
+        ? [path_1.default.resolve(appDirectory, './package.json')]
+        : [];
+    if (configFile) {
+        delete require.cache[configFile];
+        const mod = await bundleRequireWithCatch(configFile, { appDirectory });
+        config = mod.default || mod;
+        // TODO: get deps.
+        // dependencies = dependencies.concat(getDependencies(configFile));
+    }
+    return {
+        path: configFile,
+        config,
+        pkgConfig,
+        dependencies,
+    };
+};
+exports.loadConfig = loadConfig;

package/dist/{types/loadEnv.d.ts → loadEnv.d.ts}

@@ -1 +1 @@
-export declare const loadEnv: (appDirectory: string, mode?: string) => void;
+export declare const loadEnv: (appDirectory: string, mode?: string) => void;

package/dist/loadEnv.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEnv = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@modern-js/utils");
+const loadEnv = (appDirectory, mode = process.env.NODE_ENV) => {
+    // Don't change the order of the filenames， since they are ordered by the priority.
+    // Files on the left have more priority than files on the right.
+    [`.env.${mode}.local`, '.env.local', `.env.${mode}`, '.env']
+        .map(name => path_1.default.resolve(appDirectory, name))
+        .filter(filePath => fs_1.default.existsSync(filePath) && !fs_1.default.statSync(filePath).isDirectory())
+        .forEach(filePath => {
+        const envConfig = utils_1.dotenv.config({ path: filePath });
+        (0, utils_1.dotenvExpand)(envConfig);
+    });
+};
+exports.loadEnv = loadEnv;

package/dist/loadPlugins.d.ts

@@ -0,0 +1,18 @@
+import { InternalPlugins } from '@modern-js/types';
+import type { CliPlugin, UserConfig, OldPluginConfig, PluginConfig } from './types';
+export declare type TransformPlugin = (plugin: PluginConfig, resolvedConfig: UserConfig, pluginOptions?: any) => PluginConfig;
+export declare const isOldPluginConfig: (config?: PluginConfig) => config is OldPluginConfig;
+/**
+ * Load internal plugins which in @modern-js scope and user's custom plugins.
+ * @param appDirectory - Application root directory.
+ * @param userConfig - Resolved user config.
+ * @param options.internalPlugins - Internal plugins.
+ * @param options.transformPlugin - transform plugin before using it. Used for compatible with legacy jupiter plugins.
+ * @returns Plugin Objects has been required.
+ */
+export declare const loadPlugins: (appDirectory: string, userConfig: UserConfig, options?: {
+    internalPlugins?: InternalPlugins;
+    autoLoad?: InternalPlugins;
+    transformPlugin?: TransformPlugin;
+    forceAutoLoadPlugins?: boolean;
+}) => Promise<CliPlugin<{}, {}, {}, {}>[]>;

package/dist/loadPlugins.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPlugins = exports.isOldPluginConfig = void 0;
+const utils_1 = require("@modern-js/utils");
+const manager_1 = require("./manager");
+const debug = (0, utils_1.createDebugger)('load-plugins');
+const resolveCliPlugin = async (p, userConfig, appDirectory, transformPlugin) => {
+    const pkg = typeof p === 'string' ? p : p[0];
+    const pluginOptions = typeof p === 'string' ? undefined : p[1];
+    const path = (0, utils_1.tryResolve)(pkg, appDirectory);
+    let module;
+    try {
+        module = (0, utils_1.compatRequire)(path);
+    }
+    catch (e) {
+        // load esm module
+        ({ default: module } = await (0, utils_1.dynamicImport)(path));
+    }
+    if (transformPlugin) {
+        module = transformPlugin(module, userConfig, pluginOptions);
+    }
+    if (typeof module === 'function') {
+        const result = module(pluginOptions);
+        return (0, manager_1.createPlugin)(result.setup, result);
+    }
+    return module;
+};
+const isOldPluginConfig = (config) => Array.isArray(config) &&
+    config.some(item => {
+        return typeof item === 'string' || Array.isArray(item);
+    });
+exports.isOldPluginConfig = isOldPluginConfig;
+/**
+ * Load internal plugins which in @modern-js scope and user's custom plugins.
+ * @param appDirectory - Application root directory.
+ * @param userConfig - Resolved user config.
+ * @param options.internalPlugins - Internal plugins.
+ * @param options.transformPlugin - transform plugin before using it. Used for compatible with legacy jupiter plugins.
+ * @returns Plugin Objects has been required.
+ */
+const loadPlugins = async (appDirectory, userConfig, options = {}) => {
+    const pluginConfig = userConfig.plugins;
+    const plugins = [
+        ...(options.forceAutoLoadPlugins || userConfig.autoLoadPlugins
+            ? (0, utils_1.getInternalPlugins)(appDirectory, options.internalPlugins)
+            : []),
+        ...((0, exports.isOldPluginConfig)(pluginConfig) ? pluginConfig : []),
+        ...(options.autoLoad
+            ? (0, utils_1.getInternalPlugins)(appDirectory, options.autoLoad)
+            : []),
+    ];
+    const loadedPlugins = await Promise.all(plugins.map(plugin => {
+        const loadedPlugin = resolveCliPlugin(plugin, userConfig, appDirectory, options.transformPlugin);
+        // server plugins don't support to accept params
+        debug(`resolve plugin %s: %s`, plugin, loadedPlugin);
+        return loadedPlugin;
+    }));
+    if (!(0, exports.isOldPluginConfig)(pluginConfig)) {
+        if (pluginConfig === null || pluginConfig === void 0 ? void 0 : pluginConfig.length) {
+            loadedPlugins.push(...pluginConfig.map(item => (0, manager_1.createPlugin)(item.setup, item)));
+        }
+    }
+    return loadedPlugins;
+};
+exports.loadPlugins = loadPlugins;

package/dist/manager.d.ts

@@ -0,0 +1,87 @@
+import { BasePluginAPI } from './types';
+export declare const manager: import("@modern-js/plugin").AsyncManager<{
+    config: import("@modern-js/plugin").ParallelWorkflow<void, import("./types").UserConfig<{}, {}, {}, {}>>;
+    resolvedConfig: import("@modern-js/plugin").AsyncWaterfall<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
+    }>;
+    validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, any>;
+    prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    commands: import("@modern-js/plugin").AsyncWorkflow<{
+        program: import("@modern-js/utils").Command;
+    }, void>;
+    beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
+}, BasePluginAPI<{}, {}, {}, {}>>;
+export declare const createPlugin: (setup?: import("@modern-js/plugin").AsyncSetup<{
+    config: import("@modern-js/plugin").ParallelWorkflow<void, import("./types").UserConfig<{}, {}, {}, {}>>;
+    resolvedConfig: import("@modern-js/plugin").AsyncWaterfall<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
+    }>;
+    validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, any>;
+    prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    commands: import("@modern-js/plugin").AsyncWorkflow<{
+        program: import("@modern-js/utils").Command;
+    }, void>;
+    beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
+}, BasePluginAPI<{}, {}, {}, {}>> | undefined, options?: import("@modern-js/plugin").PluginOptions<{
+    config: import("@modern-js/plugin").ParallelWorkflow<void, import("./types").UserConfig<{}, {}, {}, {}>>;
+    resolvedConfig: import("@modern-js/plugin").AsyncWaterfall<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
+    }>;
+    validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, any>;
+    prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    commands: import("@modern-js/plugin").AsyncWorkflow<{
+        program: import("@modern-js/utils").Command;
+    }, void>;
+    beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
+}, import("@modern-js/plugin").AsyncSetup<{
+    config: import("@modern-js/plugin").ParallelWorkflow<void, import("./types").UserConfig<{}, {}, {}, {}>>;
+    resolvedConfig: import("@modern-js/plugin").AsyncWaterfall<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
+    }>;
+    validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, any>;
+    prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    commands: import("@modern-js/plugin").AsyncWorkflow<{
+        program: import("@modern-js/utils").Command;
+    }, void>;
+    beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
+}, BasePluginAPI<{}, {}, {}, {}>>, Record<string, unknown>> | undefined) => import("@modern-js/plugin").AsyncPlugin<{
+    config: import("@modern-js/plugin").ParallelWorkflow<void, import("./types").UserConfig<{}, {}, {}, {}>>;
+    resolvedConfig: import("@modern-js/plugin").AsyncWaterfall<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
+    }>;
+    validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, any>;
+    prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    commands: import("@modern-js/plugin").AsyncWorkflow<{
+        program: import("@modern-js/utils").Command;
+    }, void>;
+    beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
+}, BasePluginAPI<{}, {}, {}, {}>>, registerHook: (newHooks: Partial<{
+    config: import("@modern-js/plugin").ParallelWorkflow<void, import("./types").UserConfig<{}, {}, {}, {}>>;
+    resolvedConfig: import("@modern-js/plugin").AsyncWaterfall<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
+    }>;
+    validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, any>;
+    prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    commands: import("@modern-js/plugin").AsyncWorkflow<{
+        program: import("@modern-js/utils").Command;
+    }, void>;
+    beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
+}>) => void, mountHook: () => import("@modern-js/plugin").ToRunners<{
+    config: import("@modern-js/plugin").ParallelWorkflow<void, import("./types").UserConfig<{}, {}, {}, {}>>;
+    resolvedConfig: import("@modern-js/plugin").AsyncWaterfall<{
+        resolved: import("./types").NormalizedConfig<{}, {}, {}, {}>;
+    }>;
+    validateSchema: import("@modern-js/plugin").ParallelWorkflow<void, any>;
+    prepare: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    commands: import("@modern-js/plugin").AsyncWorkflow<{
+        program: import("@modern-js/utils").Command;
+    }, void>;
+    beforeExit: import("@modern-js/plugin").AsyncWorkflow<void, void>;
+    addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
+}>;

package/dist/manager.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mountHook = exports.registerHook = exports.createPlugin = exports.manager = void 0;
+const plugin_1 = require("@modern-js/plugin");
+const context_1 = require("./context");
+// eslint-disable-next-line @typescript-eslint/ban-types
+const baseHooks = {
+    config: (0, plugin_1.createParallelWorkflow)(),
+    resolvedConfig: (0, plugin_1.createAsyncWaterfall)(),
+    validateSchema: (0, plugin_1.createParallelWorkflow)(),
+    prepare: (0, plugin_1.createAsyncWorkflow)(),
+    commands: (0, plugin_1.createAsyncWorkflow)(),
+    beforeExit: (0, plugin_1.createAsyncWorkflow)(),
+    addRuntimeExports: (0, plugin_1.createAsyncWaterfall)(),
+};
+// eslint-disable-next-line @typescript-eslint/ban-types
+const pluginAPI = {
+    setAppContext: context_1.setAppContext,
+    useAppContext: context_1.useAppContext,
+    useConfigContext: context_1.useConfigContext,
+    useResolvedConfigContext: context_1.useResolvedConfigContext,
+};
+exports.manager = (0, plugin_1.createAsyncManager)(baseHooks, pluginAPI);
+exports.createPlugin = exports.manager.createPlugin, exports.registerHook = exports.manager.registerHook, exports.mountHook = exports.manager.useRunner;

package/dist/runBin.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { CoreOptions } from '.';
+export declare const run: (otherCoreOptions?: CoreOptions, options?: {
+    override?: boolean | ((coreOptions: CoreOptions) => Promise<CoreOptions> | CoreOptions) | undefined;
+}) => Promise<void>;

package/dist/runBin.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const utils_1 = require("@modern-js/utils");
+const _1 = require(".");
+const run = async (otherCoreOptions = {}, options = {}) => {
+    const command = process.argv[2];
+    if (!process.env.NODE_ENV) {
+        if (['build', 'start', 'serve', 'deploy', 'release'].includes(command)) {
+            process.env.NODE_ENV = 'production';
+        }
+        else if (command === 'test') {
+            process.env.NODE_ENV = 'test';
+        }
+        else {
+            process.env.NODE_ENV = 'development';
+        }
+    }
+    const { version } = require('../package.json');
+    const cliParams = (0, utils_1.minimist)(process.argv.slice(2));
+    const runOptions = {
+        version,
+    };
+    /**
+     * Commands that support specify config files
+     * Some commands can't support this feature, such as `new`
+     */
+    const SUPPORT_CONFIG_PARAM_COMMANDS = [
+        'dev',
+        'build',
+        'deploy',
+        'start',
+        'serve',
+        'inspect',
+    ];
+    const customConfigFile = cliParams.config || cliParams.c;
+    if (SUPPORT_CONFIG_PARAM_COMMANDS.includes(command) && customConfigFile) {
+        runOptions.configFile = customConfigFile;
+    }
+    if (typeof options.override === 'boolean' && options.override) {
+        await _1.cli.run(otherCoreOptions);
+    }
+    else if (typeof (options === null || options === void 0 ? void 0 : options.override) === 'function') {
+        await _1.cli.run(await options.override(runOptions));
+    }
+    else {
+        await _1.cli.run(utils_1.lodash.merge({}, runOptions, otherCoreOptions));
+    }
+};
+exports.run = run;

package/dist/schema/patchSchema.d.ts

@@ -0,0 +1,19 @@
+import { PluginValidateSchema } from '../types';
+export declare const patchSchema: (pluginSchemas: Array<PluginValidateSchema | PluginValidateSchema[]>) => {
+    type: string;
+    properties: {
+        testing: {
+            type: string;
+            additionalProperties: boolean;
+            properties: {
+                transformer: {
+                    type: string;
+                    enum: string[];
+                };
+                jest: {
+                    typeof: string[];
+                };
+            };
+        };
+    };
+};

package/dist/schema/patchSchema.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchSchema = void 0;
+const utils_1 = require("@modern-js/utils");
+const lodash_1 = require("@modern-js/utils/lodash");
+const testing_1 = require("./testing");
+const debug = (0, utils_1.createDebugger)('validate-schema');
+const patchSchema = (pluginSchemas) => {
+    const finalSchema = (0, lodash_1.cloneDeep)({
+        type: 'object',
+        properties: {
+            testing: testing_1.testing,
+        },
+    });
+    const findTargetNode = (props) => {
+        let node = finalSchema.properties;
+        for (const prop of props) {
+            if (!node[prop]) {
+                node[prop] = {
+                    type: 'object',
+                };
+            }
+            node = node[prop];
+            if (!node || !(0, utils_1.isObject)(node)) {
+                throw new Error(`add schema ${props.join('.')} error`);
+            }
+            node.properties = node.hasOwnProperty('properties')
+                ? node.properties
+                : {};
+            node = node.properties;
+        }
+        return node;
+    };
+    const finalPluginSchemas = [];
+    pluginSchemas.forEach(item => {
+        if (Array.isArray(item)) {
+            finalPluginSchemas.push(...item);
+        }
+        else {
+            finalPluginSchemas.push(item);
+        }
+    });
+    for (const { target, schema } of finalPluginSchemas) {
+        if (!target) {
+            throw new Error(`should return target property in plugin schema.`);
+        }
+        const props = target.split('.');
+        const mountProperty = props.pop();
+        const targetNode = findTargetNode(props);
+        if (!targetNode.hasOwnProperty(mountProperty)) {
+            targetNode[mountProperty] = (0, lodash_1.cloneDeep)(schema);
+        }
+    }
+    debug(`final validate schema: %o`, finalSchema);
+    return finalSchema;
+};
+exports.patchSchema = patchSchema;

package/dist/schema/source.d.ts

@@ -0,0 +1,9 @@
+export declare const source: {
+    type: string;
+    additionalProperties: boolean;
+    properties: {
+        designSystem: {
+            type: string;
+        };
+    };
+};

package/dist/schema/source.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.source = void 0;
+exports.source = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        designSystem: { type: 'object' },
+    },
+};

package/dist/schema/testing.d.ts

@@ -0,0 +1,13 @@
+export declare const testing: {
+    type: string;
+    additionalProperties: boolean;
+    properties: {
+        transformer: {
+            type: string;
+            enum: string[];
+        };
+        jest: {
+            typeof: string[];
+        };
+    };
+};

package/dist/schema/testing.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testing = void 0;
+exports.testing = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        transformer: { type: 'string', enum: ['babel-jest', 'ts-jest'] },
+        jest: { typeof: ['object', 'function'] },
+    },
+};

package/dist/schema/traverseSchema.d.ts

@@ -0,0 +1,2 @@
+import { patchSchema } from './patchSchema';
+export declare const traverseSchema: (schema: ReturnType<typeof patchSchema>) => string[];

package/dist/schema/traverseSchema.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseSchema = void 0;
+const traverseSchema = (schema) => {
+    const keys = [];
+    const traverse = ({ properties }, old = []) => {
+        for (const key of Object.keys(properties)) {
+            const current = [...old, key];
+            if (properties[key].type === 'object' && properties[key].properties) {
+                traverse(properties[key], current);
+            }
+            else {
+                keys.push(current.join('.'));
+            }
+        }
+    };
+    traverse(schema);
+    return keys;
+};
+exports.traverseSchema = traverseSchema;