@platformos/platformos-check-node 0.0.2

package/dist/config/resolve/read-yaml.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readYamlConfigDescription = readYamlConfigDescription;
+const platformos_check_common_1 = require("@platformos/platformos-check-common");
+const node_fs_1 = require("node:fs");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = require("yaml");
+const types_1 = require("../types");
+class UnresolvedAliasError extends Error {
+    constructor(message, alias) {
+        super(message);
+        this.name = 'UnresolvedAliasError';
+        this.message = `YAML parsing error: Unresolved alias *${alias}.
+Did you forget to wrap your ignore statement in quotes? '*${alias}'
+${message}`;
+    }
+}
+function parseYamlFile(absolutePath, contents) {
+    try {
+        const result = contents.trim() === '' ? {} : (0, yaml_1.parse)(contents);
+        if (!isPlainObject(result)) {
+            throw new Error(`Expecting parsed contents of config file at path '${absolutePath}' to be a plain object`);
+        }
+        return result;
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.name === 'ReferenceError' &&
+            error.message.includes('Unresolved alias') &&
+            /: .*$/m.test(error.message)) {
+            const alias = /: .*$/m.exec(error.message)[0].slice(2);
+            throw new UnresolvedAliasError(error.message, alias);
+        }
+        else {
+            throw error;
+        }
+    }
+}
+/**
+ * Takes an absolute path, parses the yaml at that path and turns it into a
+ * ConfigFragment object.
+ */
+async function readYamlConfigDescription(
+/** the absolute path to a .platformos-check.yml file */
+absolutePath, 
+/** only the root config has `extends: platformos-check:recommended` by default, it's nothing everywhere else */
+isRootConfig = false) {
+    const root = node_path_1.default.dirname(absolutePath);
+    const contents = await promises_1.default.readFile(absolutePath, 'utf8');
+    const yamlFile = parseYamlFile(absolutePath, contents);
+    const config = {
+        checkSettings: {},
+        ignore: [],
+        extends: [],
+        require: [],
+    };
+    if (yamlFile.root) {
+        config.root = yamlFile.root;
+        delete yamlFile.root;
+    }
+    if (yamlFile.ignore) {
+        config.ignore = asArray(yamlFile.ignore);
+        delete yamlFile.ignore;
+    }
+    if (yamlFile.require) {
+        config.require = asArray(yamlFile.require)
+            .map((pathLike) => resolvePath(root, pathLike))
+            .filter(isString);
+        delete yamlFile.require;
+    }
+    if (yamlFile.extends) {
+        config.extends = asArray(yamlFile.extends)
+            .map((pathLike) => resolveExtends(root, pathLike))
+            .filter(isString);
+        delete yamlFile.extends;
+    }
+    else if (isRootConfig) {
+        config.extends = [resolveExtends(root, 'platformos-check:recommended')];
+    }
+    if (yamlFile.context) {
+        if (platformos_check_common_1.Modes.includes(yamlFile.context)) {
+            config.context = yamlFile.context;
+        }
+        delete yamlFile.context;
+    }
+    // legacy settings that screw up assumptions
+    if (yamlFile.include_categories)
+        delete yamlFile.include_categories;
+    if (yamlFile.exclude_categories)
+        delete yamlFile.exclude_categories;
+    for (const [checkName, settings] of Object.entries(yamlFile)) {
+        if (!isPlainObject(settings)) {
+            throw new Error(`Expected a plain object value for ${checkName} but got ${typeof settings}`);
+        }
+        config.checkSettings[checkName] = resolveSettings(settings);
+    }
+    return config;
+}
+/**
+ * resolves the `extends:` property of configuration files.
+ *
+ * pathLike can be any of the following:
+ * - modern identifiers:
+ *   - platformos-check:all
+ *   - platformos-check:recommended
+ *   - platformos-check:nothing
+ * - a node_module (e.g. '@acme/platformos-check-recommended')
+ * - a relative path (e.g. '../configurations/.platformos-check.yml')
+ *
+ * @returns {string} resolved absolute path of the extended config
+ */
+function resolveExtends(
+/** absolute path of the config file */
+root, 
+/** pathLike textual value of the `extends` property in the config file */
+pathLike) {
+    if (pathLike.startsWith('platformos-check:')) {
+        return pathLike;
+    }
+    return resolvePath(root, pathLike);
+}
+/**
+ * resolves a pathLike property from the configuration file.
+ *
+ * pathLike can be any of the following:
+ *   - a node_module (e.g. '@acme/platformos-check-extension')
+ *   - a relative path (e.g. './lib/main.js')
+ *
+ * @returns {string} resolved absolute path of the extended config
+ */
+function resolvePath(
+/** absolute path of the config file */
+root, 
+/** pathLike textual value of the `extends` property in the config file */
+pathLike) {
+    if (node_path_1.default.isAbsolute(pathLike)) {
+        return pathLike;
+    }
+    if (pathLike.startsWith('.')) {
+        return node_path_1.default.resolve(root, pathLike);
+    }
+    return (0, node_fs_1.realpathSync)(require.resolve(pathLike, { paths: getAncestorNodeModules(root) }));
+}
+/**
+ * Resolves the check settings. Will also camelCase the snake_case settings
+ * for backwards compatibility.
+ */
+function resolveSettings(
+/** key value pair of settings for a check */
+settings) {
+    const resolvedSettings = {
+        enabled: settings.enabled || true,
+    };
+    for (const [key, value] of Object.entries(settings)) {
+        resolvedSettings[toCamelCase(key)] = value;
+    }
+    if (settings.ignore !== undefined &&
+        Array.isArray(settings.ignore) &&
+        settings.ignore.every(isString)) {
+        resolvedSettings.ignore = settings.ignore;
+    }
+    if (settings.severity !== undefined) {
+        resolvedSettings.severity = resolveSeverity(settings.severity);
+    }
+    return resolvedSettings;
+}
+function resolveSeverity(severity) {
+    if (isConvenienceSeverity(severity))
+        return types_1.ConvenienceSeverities[severity];
+    if (isSeverity(severity))
+        return severity;
+    throw new Error(`Unsupported severity: ${severity}. Try one of ${Object.keys(types_1.ConvenienceSeverities)}`);
+}
+function isConvenienceSeverity(severity) {
+    return typeof severity === 'string' && severity in types_1.ConvenienceSeverities;
+}
+function isSeverity(severity) {
+    return typeof severity === 'number' && severity in platformos_check_common_1.Severity;
+}
+function toCamelCase(maybeSnakeCaseStr) {
+    return maybeSnakeCaseStr.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function isPlainObject(thing) {
+    return Object.prototype.toString.call(thing) === '[object Object]';
+}
+function isString(thing) {
+    return typeof thing === 'string';
+}
+function asArray(thing) {
+    return Array.isArray(thing) ? thing : [thing];
+}
+function getAncestorNodeModules(dir) {
+    const root = node_path_1.default.parse(dir).root;
+    const nodeModulesPaths = [];
+    while (dir !== root) {
+        nodeModulesPaths.push(node_path_1.default.join(dir, 'node_modules'));
+        dir = node_path_1.default.dirname(dir);
+    }
+    return nodeModulesPaths;
+}
+//# sourceMappingURL=read-yaml.js.map

package/dist/config/resolve/resolve-config.d.ts

@@ -0,0 +1,8 @@
+import { ConfigDescription, ModernIdentifier } from '../types';
+import { AbsolutePath } from '../../temp';
+/**
+ * Given a modern identifier or absolute path, fully resolves and flattens
+ * a config description. In other words, extends are all loaded and merged with
+ * the config at the configPath.
+ */
+export declare function resolveConfig(configPath: AbsolutePath | ModernIdentifier, isRootConfig?: boolean): Promise<ConfigDescription>;

package/dist/config/resolve/resolve-config.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = resolveConfig;
+const node_path_1 = __importDefault(require("node:path"));
+const read_yaml_1 = require("./read-yaml");
+const merge_fragments_1 = require("./merge-fragments");
+const types_1 = require("../types");
+const modernConfigsPath = () => {
+    if (process.env.WEBPACK_MODE) {
+        return node_path_1.default.resolve(__dirname, './configs');
+    }
+    else {
+        return node_path_1.default.resolve(__dirname, '../../../configs');
+    }
+};
+/**
+ * Given a modern identifier or absolute path, fully resolves and flattens
+ * a config description. In other words, extends are all loaded and merged with
+ * the config at the configPath.
+ */
+async function resolveConfig(configPath, isRootConfig = false) {
+    if (isModernIdentifier(configPath)) {
+        const modernConfigPath = node_path_1.default.join(modernConfigsPath(), configPath.replace(/^platformos-check:/, '') + '.yml');
+        return resolveConfig(modernConfigPath);
+    }
+    // TODO: Add support for more file formats.
+    const current = await (0, read_yaml_1.readYamlConfigDescription)(configPath, isRootConfig);
+    const baseConfigs = await Promise.all(current.extends.map((extend) => resolveConfig(extend)));
+    return (0, merge_fragments_1.mergeFragments)(baseConfigs, current);
+}
+function isModernIdentifier(thing) {
+    return types_1.ModernIdentifiers.includes(thing);
+}
+//# sourceMappingURL=resolve-config.js.map

package/dist/config/types.d.ts

@@ -0,0 +1,35 @@
+import { ChecksSettings, Mode, Severity } from '@platformos/platformos-check-common';
+/**
+ * The pipeline goes like this:
+ *
+ * File                   # the input file as a string
+ * -> ConfigFragment      # an intermediate representation of the file
+ * -> ConfigFragment[]    # the file and its extends
+ * -> ConfigDescription   # the flattened config (no extends)
+ * -> Config              # the theme check config
+ *
+ * Our goal is to support more than one config file format, so what we'll
+ * do is have one adapter per file format that outputs a ConfigFragment.
+ *
+ * Then we'll be able to merge all the config fragments, independently of
+ * which file format used.
+ */
+export interface ConfigFragment {
+    root?: string;
+    ignore: string[];
+    extends: string[];
+    require: string[];
+    checkSettings: ChecksSettings;
+    context?: Mode;
+}
+/** A ConfigDescription is a ConfigFragment that doesn't extend anything. */
+export type ConfigDescription = Omit<ConfigFragment, 'extends' | 'context'> & {
+    extends: [];
+    context: Mode;
+};
+export declare const ModernIdentifiers: readonly ["platformos-check:nothing", "platformos-check:recommended", "platformos-check:all"];
+export type ModernIdentifier = (typeof ModernIdentifiers)[number];
+export type ConvenienceSeverity = 'error' | 'suggestion' | 'style' | 'warning' | 'info';
+export declare const ConvenienceSeverities: {
+    [k in ConvenienceSeverity]: Severity;
+};

package/dist/config/types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConvenienceSeverities = exports.ModernIdentifiers = void 0;
+const platformos_check_common_1 = require("@platformos/platformos-check-common");
+exports.ModernIdentifiers = [
+    'platformos-check:nothing',
+    'platformos-check:recommended',
+    'platformos-check:all',
+];
+exports.ConvenienceSeverities = {
+    // legacy
+    suggestion: platformos_check_common_1.Severity.WARNING,
+    style: platformos_check_common_1.Severity.INFO,
+    // the numerical values are not user friendly
+    error: platformos_check_common_1.Severity.ERROR,
+    warning: platformos_check_common_1.Severity.WARNING,
+    info: platformos_check_common_1.Severity.INFO,
+};
+//# sourceMappingURL=types.js.map

package/dist/config/validation.d.ts

@@ -0,0 +1,2 @@
+import { Config } from '@platformos/platformos-check-common';
+export declare function validateConfig(config: Config): void;

package/dist/config/validation.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = validateConfig;
+const node_assert_1 = require("node:assert");
+function validateConfig(config) {
+    for (const check of config.checks) {
+        const settings = config.settings[check.meta.code];
+        (0, node_assert_1.strict)(settings, `Unexpected missing settings for ${check.meta.code} in validateConfig call`);
+        validateSettings(check.meta.code, check.meta.schema, settings, true);
+    }
+}
+function validateSettings(checkCode, schema, settings, isTopLevel) {
+    for (const key in schema) {
+        const schemaProp = schema[key];
+        const settingValue = settings[key];
+        validateValue(key, settingValue, schemaProp);
+    }
+    if (isTopLevel) {
+        validateCommonCheckSettings(settings);
+    }
+    validateSuperfluousSettings(checkCode, schema, settings);
+}
+function validateCommonCheckSettings(settings) {
+    const { severity, enabled, ignore } = settings;
+    severity === undefined || assertType('severity', 'number', typeof severity);
+    assertType('enabled', 'boolean', typeof enabled);
+    ignore === undefined || assertArray('ignore', ignore);
+}
+function validateSuperfluousSettings(checkCode, schema, settings) {
+    const commonCheckSettingsKeys = ['enabled', 'severity', 'ignore'];
+    for (const key in settings) {
+        if (!(key in schema) && !commonCheckSettingsKeys.includes(key)) {
+            console.error(`Unexpected setting: ${key} for check ${checkCode} found in configuration`);
+        }
+    }
+}
+function validateValue(key, value, schemaProp) {
+    const { type, optional, defaultValue, properties, itemType } = schemaProp.options;
+    if (value === undefined) {
+        if (optional !== true && defaultValue === undefined) {
+            throw new Error(`Missing required setting: ${key}`);
+        }
+        return;
+    }
+    if (defaultValue !== undefined && value === defaultValue) {
+        return;
+    }
+    switch (type) {
+        case 'string':
+        case 'number':
+        case 'boolean': {
+            assertType(key, type, typeof value);
+            break;
+        }
+        case 'object': {
+            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                throw new Error(`Invalid type for setting ${key}: expected object, got ${typeof value}`);
+            }
+            for (const nestedKey in properties) {
+                validateValue(nestedKey, value[nestedKey], properties[nestedKey]);
+            }
+            break;
+        }
+        case 'array': {
+            assertArray(key, value);
+            if (itemType) {
+                for (const item of value) {
+                    validateValue(key, item, itemType);
+                }
+            }
+            break;
+        }
+        default: {
+            throw new Error(`Unexpected setting type: ${type}`);
+        }
+    }
+}
+const typeOf = (thing) => typeof thing;
+function assertType(key, expectedType, actualType) {
+    node_assert_1.strict.strictEqual(actualType, expectedType, `Invalid type for setting ${key}: expected ${expectedType}, got ${actualType}`);
+}
+function assertArray(key, thing) {
+    node_assert_1.strict.ok(Array.isArray(thing), `Invalid type for setting ${key}: expected array, got ${typeof thing}`);
+}
+//# sourceMappingURL=validation.js.map

package/dist/file-utils.d.ts

@@ -0,0 +1 @@
+export declare function fileExists(path: string): Promise<boolean>;

package/dist/file-utils.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileExists = fileExists;
+const promises_1 = __importDefault(require("node:fs/promises"));
+async function fileExists(path) {
+    try {
+        await promises_1.default.stat(path);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+//# sourceMappingURL=file-utils.js.map

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import { Config, GraphQLSourceCode, JSONSourceCode, LiquidSourceCode, Offense, Theme } from '@platformos/platformos-check-common';
+import { loadConfig as resolveConfig } from './config';
+import { NodeFileSystem } from './NodeFileSystem';
+export * from '@platformos/platformos-check-common';
+export * from './config/types';
+export { NodeFileSystem };
+export { runBackfillDocsCLI } from './backfill-docs';
+export declare const loadConfig: typeof resolveConfig;
+export type ThemeCheckRun = {
+    theme: Theme;
+    config: Config;
+    offenses: Offense[];
+};
+export declare function toSourceCode(absolutePath: string): Promise<LiquidSourceCode | JSONSourceCode | GraphQLSourceCode | undefined>;
+export declare function check(root: string, configPath?: string): Promise<Offense[]>;
+export declare function checkAndAutofix(root: string, configPath?: string): Promise<void>;
+export declare function themeCheckRun(root: string, configPath?: string, log?: (message: string) => void): Promise<ThemeCheckRun>;
+export declare function getThemeAndConfig(root: string, configPath?: string): Promise<{
+    theme: Theme;
+    config: Config;
+}>;
+export declare function getTheme(config: Config): Promise<Theme>;
+export declare function getThemeFilesPathPattern(rootUri: string): string;

package/dist/index.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = exports.runBackfillDocsCLI = exports.NodeFileSystem = void 0;
+exports.toSourceCode = toSourceCode;
+exports.check = check;
+exports.checkAndAutofix = checkAndAutofix;
+exports.themeCheckRun = themeCheckRun;
+exports.getThemeAndConfig = getThemeAndConfig;
+exports.getTheme = getTheme;
+exports.getThemeFilesPathPattern = getThemeFilesPathPattern;
+const platformos_check_common_1 = require("@platformos/platformos-check-common");
+const platformos_check_docs_updater_1 = require("@platformos/platformos-check-docs-updater");
+const liquid_html_parser_1 = require("@platformos/liquid-html-parser");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const vscode_uri_1 = require("vscode-uri");
+const glob = require("glob");
+const autofix_1 = require("./autofix");
+const config_1 = require("./config");
+const NodeFileSystem_1 = require("./NodeFileSystem");
+Object.defineProperty(exports, "NodeFileSystem", { enumerable: true, get: function () { return NodeFileSystem_1.NodeFileSystem; } });
+const node_url_1 = require("node:url");
+const asyncGlob = (0, node_util_1.promisify)(glob);
+__exportStar(require("@platformos/platformos-check-common"), exports);
+__exportStar(require("./config/types"), exports);
+var backfill_docs_1 = require("./backfill-docs");
+Object.defineProperty(exports, "runBackfillDocsCLI", { enumerable: true, get: function () { return backfill_docs_1.runBackfillDocsCLI; } });
+const loadConfig = async (configPath, root) => {
+    configPath ??= await (0, config_1.findConfigPath)(root);
+    return (0, config_1.loadConfig)(configPath, root);
+};
+exports.loadConfig = loadConfig;
+async function toSourceCode(absolutePath) {
+    try {
+        const source = await promises_1.default.readFile(absolutePath, 'utf8');
+        return (0, platformos_check_common_1.toSourceCode)(platformos_check_common_1.path.normalize(vscode_uri_1.URI.file(absolutePath)), source);
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+async function check(root, configPath) {
+    const run = await themeCheckRun(root, configPath);
+    return run.offenses;
+}
+async function checkAndAutofix(root, configPath) {
+    const { theme, offenses } = await themeCheckRun(root, configPath);
+    await (0, autofix_1.autofix)(theme, offenses);
+}
+async function themeCheckRun(root, configPath, log = () => { }) {
+    const { theme, config } = await getThemeAndConfig(root, configPath);
+    const themeLiquidDocsManager = new platformos_check_docs_updater_1.ThemeLiquidDocsManager(log);
+    // This does feel a bit heavy handed, but I'm in a rush.
+    //
+    // Ultimately, I want to be able to have type safety on the parsed content
+    // of the {% schema %} tags if the schema is known to be valid. This should make
+    // {% schema %} related theme checks much easier to write than having to write visitor
+    // code and doing null checks all over the place. `ThemeBlock.Schema` is much more specific
+    // than `any` ever could be.
+    //
+    // I also want to have the option of passing down the getSectionSchema &
+    // getBlockSchema functions as dependencies. This will enable me to cache the
+    // results in the language server and avoid redoing validation between runs if
+    // we know the schema of a file that didn't change is valid.
+    //
+    // The crux of my problem is that I want to be passing down the json validation set
+    // as dependencies and not a full blown language service. But the easiest way
+    // is to have a `isValidSchema` is to have the language service do the
+    // validation of the JSON schema... We're technically going to have two
+    // JSONValidator running in theme check (node). We already have two in the
+    // language server.
+    const validator = await platformos_check_common_1.JSONValidator.create(themeLiquidDocsManager, config);
+    const isValidSchema = validator?.isValid;
+    // We can assume that all files are loaded when running themeCheckRun
+    const schemas = theme.map((source) => (0, platformos_check_common_1.toSchema)(config.context, source.uri, source, isValidSchema));
+    // prettier-ignore
+    const blockSchemas = new Map(theme.filter(source => (0, platformos_check_common_1.isBlock)(source.uri)).map((source) => [
+        node_path_1.default.basename(source.uri, '.liquid'),
+        (0, platformos_check_common_1.memo)(async () => (0, platformos_check_common_1.toSchema)(config.context, source.uri, source, isValidSchema))
+    ]));
+    // prettier-ignore
+    const sectionSchemas = new Map(theme.filter(source => (0, platformos_check_common_1.isSection)(source.uri)).map((source) => [
+        node_path_1.default.basename(source.uri, '.liquid'),
+        (0, platformos_check_common_1.memo)(async () => (0, platformos_check_common_1.toSchema)(config.context, source.uri, source, isValidSchema))
+    ]));
+    const docDefinitions = new Map(theme.map((file) => [
+        node_path_1.default.relative(vscode_uri_1.URI.file(root).toString(), file.uri),
+        (0, platformos_check_common_1.memo)(async () => {
+            const ast = file.ast;
+            if (!(0, liquid_html_parser_1.isLiquidHtmlNode)(ast)) {
+                return undefined;
+            }
+            if (!(0, platformos_check_common_1.filePathSupportsLiquidDoc)(file.uri)) {
+                return undefined;
+            }
+            return (0, platformos_check_common_1.extractDocDefinition)(file.uri, ast);
+        }),
+    ]));
+    const offenses = await (0, platformos_check_common_1.check)(theme, config, {
+        fs: NodeFileSystem_1.NodeFileSystem,
+        themeDocset: themeLiquidDocsManager,
+        jsonValidationSet: themeLiquidDocsManager,
+        // This is kind of gross, but we want those things to be lazy and called by name so...
+        // In the language server, this is memo'ed in DocumentManager, but we don't have that kind
+        // of luxury in CLI-mode.
+        getSectionSchema: async (name) => sectionSchemas.get(name)?.(),
+        getBlockSchema: async (name) => blockSchemas.get(name)?.(),
+        getAppBlockSchema: async (name) => blockSchemas.get(name)?.(), // cheating... but TODO
+        getDocDefinition: async (relativePath) => docDefinitions.get(relativePath)?.(),
+    });
+    return {
+        theme,
+        config,
+        offenses,
+    };
+}
+async function getThemeAndConfig(root, configPath) {
+    const config = await (0, exports.loadConfig)(configPath, root);
+    const theme = await getTheme(config);
+    return {
+        theme,
+        config,
+    };
+}
+async function getTheme(config) {
+    // On windows machines - the separator provided by path.join is '\'
+    // however the glob function fails silently since '\' is used to escape glob charater
+    // as mentioned in the documentation of node-glob
+    // the path is normalised and '\' are replaced with '/' and then passed to the glob function
+    let normalizedGlob = getThemeFilesPathPattern(config.rootUri);
+    const paths = await asyncGlob(normalizedGlob, { absolute: true }).then((result) => 
+    // Global ignored paths should not be part of the theme
+    result.filter((filePath) => !(0, platformos_check_common_1.isIgnored)(filePath, config)));
+    const sourceCodes = await Promise.all(paths.map(toSourceCode));
+    return sourceCodes.filter((x) => x !== undefined);
+}
+function getThemeFilesPathPattern(rootUri) {
+    return node_path_1.default
+        .normalize(node_path_1.default.join((0, node_url_1.fileURLToPath)(rootUri), '**/*.{liquid,json,graphql}'))
+        .replace(/\\/g, '/');
+}
+//# sourceMappingURL=index.js.map

package/dist/temp.d.ts

@@ -0,0 +1,2 @@
+/** Temporarily keeping this. Should remove with #532 */
+export type AbsolutePath = string;

package/dist/temp.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=temp.js.map

package/dist/test/test-helpers.d.ts

@@ -0,0 +1,14 @@
+export declare function makeTmpFolder(): Promise<string>;
+export declare function removeTmpFolder(tempDir: string): Promise<void>;
+export declare function createMockConfigFile(tempDir: string, contents?: string, relativePath?: string): Promise<string>;
+export declare const mockNodeModuleCheck = "\n  const NodeModuleCheck = {\n    meta: {\n      name: 'NodeModuleCheck',\n      code: 'NodeModuleCheck',\n      docs: { description: '...' },\n      schema: {},\n      severity: 0,\n      targets: [],\n      type: 'LiquidHtml',\n    },\n    create() {\n      return {};\n    },\n  };\n\n  exports.checks = [\n    NodeModuleCheck,\n  ];\n";
+export declare function createMockNodeModule(tempDir: string, moduleName: string, moduleContent?: string): Promise<string>;
+export type Tree = {
+    [k in string]: Tree | string;
+};
+export interface Workspace {
+    rootUri: string;
+    uri(relativePath: string): string;
+    clean(): Promise<any>;
+}
+export declare function makeTempWorkspace(structure: Tree): Promise<Workspace>;