@platformos/platformos-check-node 0.0.2

package/dist/commands/generate-docs.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDocsCommand = generateDocsCommand;
+exports.generateDocForFile = generateDocForFile;
+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 asyncGlob = (0, node_util_1.promisify)(glob);
+/**
+ * Generate doc blocks for all partials and blocks in a theme.
+ */
+async function generateDocsCommand(root, options = {}) {
+    const { dryRun = false, output = 'inline' } = options;
+    const rootUri = platformos_check_common_1.path.normalize(vscode_uri_1.URI.file(root));
+    const themeLiquidDocsManager = new platformos_check_docs_updater_1.ThemeLiquidDocsManager(console.error.bind(console));
+    // Find all liquid files that support doc blocks (partials and blocks)
+    const partialsGlob = node_path_1.default
+        .normalize(node_path_1.default.join(root, 'app/views/partials/**/*.liquid'))
+        .replace(/\\/g, '/');
+    const blocksGlob = node_path_1.default
+        .normalize(node_path_1.default.join(root, 'blocks/**/*.liquid'))
+        .replace(/\\/g, '/');
+    const [partialPaths, blockPaths] = await Promise.all([
+        asyncGlob(partialsGlob, { absolute: true }),
+        asyncGlob(blocksGlob, { absolute: true }),
+    ]);
+    const allPaths = [...partialPaths, ...blockPaths];
+    const results = [];
+    for (const absolutePath of allPaths) {
+        const uri = platformos_check_common_1.path.normalize(vscode_uri_1.URI.file(absolutePath));
+        // Double-check this file supports doc blocks
+        if (!(0, platformos_check_common_1.filePathSupportsLiquidDoc)(uri))
+            continue;
+        // Read and parse the file
+        const source = await promises_1.default.readFile(absolutePath, 'utf8');
+        const sourceCode = (0, platformos_check_common_1.toSourceCode)(uri, source);
+        if (!sourceCode || sourceCode.type !== platformos_check_common_1.SourceCodeType.LiquidHtml)
+            continue;
+        const ast = sourceCode.ast;
+        if (!(0, liquid_html_parser_1.isLiquidHtmlNode)(ast))
+            continue;
+        // Generate doc block
+        const docResult = await (0, platformos_check_common_1.generateDocBlock)(ast, uri, themeLiquidDocsManager);
+        const relativePath = node_path_1.default.relative(root, absolutePath);
+        const result = {
+            uri,
+            relativePath,
+            parameters: docResult.parameters,
+            docBlockText: docResult.docBlockText,
+            hasExistingDocBlock: docResult.hasExistingDocBlock,
+            updated: false,
+        };
+        // Skip files that already have doc blocks
+        if (docResult.hasExistingDocBlock) {
+            results.push(result);
+            continue;
+        }
+        // Skip files with no detected parameters
+        if (docResult.parameters.length === 0) {
+            results.push(result);
+            continue;
+        }
+        // If not dry run and output is inline, write the doc block to the file
+        if (!dryRun && output === 'inline') {
+            const newSource = docResult.docBlockText + '\n\n' + source;
+            await promises_1.default.writeFile(absolutePath, newSource, 'utf8');
+            result.updated = true;
+        }
+        results.push(result);
+    }
+    // Output based on mode
+    if (output === 'stdout') {
+        for (const result of results) {
+            if (result.hasExistingDocBlock) {
+                console.log(`[SKIP] ${result.relativePath} - already has doc block`);
+            }
+            else if (result.parameters.length === 0) {
+                console.log(`[SKIP] ${result.relativePath} - no parameters detected`);
+            }
+            else if (dryRun) {
+                console.log(`[DRY-RUN] ${result.relativePath}`);
+                console.log(result.docBlockText);
+                console.log('');
+            }
+            else {
+                console.log(`[UPDATED] ${result.relativePath}`);
+            }
+        }
+    }
+    else if (output === 'json') {
+        console.log(JSON.stringify(results, null, 2));
+    }
+    return results;
+}
+/**
+ * Generate doc block for a single file.
+ */
+async function generateDocForFile(absolutePath, options = {}) {
+    const { dryRun = false } = options;
+    const uri = platformos_check_common_1.path.normalize(vscode_uri_1.URI.file(absolutePath));
+    if (!(0, platformos_check_common_1.filePathSupportsLiquidDoc)(uri)) {
+        return null;
+    }
+    const themeLiquidDocsManager = new platformos_check_docs_updater_1.ThemeLiquidDocsManager(console.error.bind(console));
+    const source = await promises_1.default.readFile(absolutePath, 'utf8');
+    const sourceCode = (0, platformos_check_common_1.toSourceCode)(uri, source);
+    if (!sourceCode || sourceCode.type !== platformos_check_common_1.SourceCodeType.LiquidHtml)
+        return null;
+    const ast = sourceCode.ast;
+    if (!(0, liquid_html_parser_1.isLiquidHtmlNode)(ast))
+        return null;
+    const docResult = await (0, platformos_check_common_1.generateDocBlock)(ast, uri, themeLiquidDocsManager);
+    const result = {
+        uri,
+        relativePath: absolutePath,
+        parameters: docResult.parameters,
+        docBlockText: docResult.docBlockText,
+        hasExistingDocBlock: docResult.hasExistingDocBlock,
+        updated: false,
+    };
+    if (!docResult.hasExistingDocBlock && docResult.parameters.length > 0 && !dryRun) {
+        const newSource = docResult.docBlockText + '\n\n' + source;
+        await promises_1.default.writeFile(absolutePath, newSource, 'utf8');
+        result.updated = true;
+    }
+    return result;
+}
+//# sourceMappingURL=generate-docs.js.map

package/dist/commands/index.d.ts

@@ -0,0 +1 @@
+export { generateDocsCommand, generateDocForFile, GenerateDocsOptions, GenerateDocsResult, } from './generate-docs';

package/dist/commands/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDocForFile = exports.generateDocsCommand = void 0;
+var generate_docs_1 = require("./generate-docs");
+Object.defineProperty(exports, "generateDocsCommand", { enumerable: true, get: function () { return generate_docs_1.generateDocsCommand; } });
+Object.defineProperty(exports, "generateDocForFile", { enumerable: true, get: function () { return generate_docs_1.generateDocForFile; } });
+//# sourceMappingURL=index.js.map

package/dist/config/find-config-path.d.ts

@@ -0,0 +1 @@
+export declare function findConfigPath(root: string): Promise<string | undefined>;

package/dist/config/find-config-path.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findConfigPath = findConfigPath;
+const node_path_1 = __importDefault(require("node:path"));
+const file_utils_1 = require("../file-utils");
+const DiscoverableConfigFileNames = ['.platformos-check.yml'];
+function findConfigPath(root) {
+    const paths = DiscoverableConfigFileNames.map((file) => node_path_1.default.join(root, file));
+    return find(paths, file_utils_1.fileExists);
+}
+async function find(array, pred) {
+    for (const el of array) {
+        if (await pred(el)) {
+            return el;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=find-config-path.js.map

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export { loadConfig } from './load-config';
+export { findConfigPath } from './find-config-path';

package/dist/config/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findConfigPath = exports.loadConfig = void 0;
+var load_config_1 = require("./load-config");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return load_config_1.loadConfig; } });
+var find_config_path_1 = require("./find-config-path");
+Object.defineProperty(exports, "findConfigPath", { enumerable: true, get: function () { return find_config_path_1.findConfigPath; } });
+//# sourceMappingURL=index.js.map

package/dist/config/installation-location.d.ts

@@ -0,0 +1 @@
+export declare const thisNodeModuleRoot: () => string;

package/dist/config/installation-location.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thisNodeModuleRoot = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+// This is used to load global checks (in the context where someone installed the CLI globally)
+// This shouldn't be used by VS Code since it's baked into the extension with webpack.
+const thisNodeModuleRoot = () => {
+    if (process.env.WEBPACK_MODE) {
+        return node_os_1.default.tmpdir();
+    }
+    else {
+        return node_path_1.default.resolve(node_path_1.default.join(__dirname, '..', '..'));
+    }
+};
+exports.thisNodeModuleRoot = thisNodeModuleRoot;
+//# sourceMappingURL=installation-location.js.map

package/dist/config/load-config-description.d.ts

@@ -0,0 +1,10 @@
+import { Config } from '@platformos/platformos-check-common';
+import { AbsolutePath } from '../temp';
+import { ConfigDescription } from './types';
+/**
+ * Creates the checks array, loads node modules checks and validates
+ * settings against the respective check schemas.
+ *
+ * Effectively "loads" a ConfigDescription into a Config.
+ */
+export declare function loadConfigDescription(configDescription: ConfigDescription, root: AbsolutePath): Promise<Config>;

package/dist/config/load-config-description.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfigDescription = loadConfigDescription;
+const platformos_check_common_1 = require("@platformos/platformos-check-common");
+const node_path_1 = __importDefault(require("node:path"));
+const file_utils_1 = require("../file-utils");
+const installation_location_1 = require("./installation-location");
+const load_third_party_checks_1 = require("./load-third-party-checks");
+const vscode_uri_1 = require("vscode-uri");
+const flatten = (arrs) => arrs.flat();
+/**
+ * Creates the checks array, loads node modules checks and validates
+ * settings against the respective check schemas.
+ *
+ * Effectively "loads" a ConfigDescription into a Config.
+ */
+async function loadConfigDescription(configDescription, root) {
+    const nodeModuleRoot = await findNodeModuleRoot(root);
+    const thirdPartyChecksPaths = await Promise.all([
+        (0, load_third_party_checks_1.findThirdPartyChecks)((0, installation_location_1.thisNodeModuleRoot)()), // global checks
+        (0, load_third_party_checks_1.findThirdPartyChecks)(nodeModuleRoot),
+    ]).then(flatten);
+    const thirdPartyChecks = (0, load_third_party_checks_1.loadThirdPartyChecks)([
+        ...configDescription.require,
+        ...thirdPartyChecksPaths,
+    ]);
+    const checks = platformos_check_common_1.allChecks
+        .concat(thirdPartyChecks)
+        .filter(isEnabledBy(configDescription));
+    const rootUri = vscode_uri_1.URI.file(root);
+    return {
+        settings: unaliasedSettings(configDescription.checkSettings, checks),
+        context: configDescription.context ?? 'theme',
+        checks,
+        ignore: configDescription.ignore,
+        rootUri: resolveRoot(rootUri, configDescription.root),
+    };
+}
+/**
+ * @param root - absolute path of the config file
+ * @param pathLike - resolved textual value of the `root` property from the config files
+ * @returns {string} resolved URI of the root property
+ */
+function resolveRoot(root, pathLike) {
+    if (pathLike === undefined) {
+        return platformos_check_common_1.path.normalize(root);
+    }
+    if (node_path_1.default.isAbsolute(pathLike)) {
+        throw new Error('the "root" property can only be relative');
+    }
+    return platformos_check_common_1.path.resolve(root, pathLike);
+}
+const isEnabledBy = (config) => (checkDefinition) => {
+    const checkSettings = config.checkSettings[checkDefinition.meta.code] ?? aliasedSettings(config, checkDefinition);
+    if (!checkSettings)
+        return false;
+    return checkSettings.enabled;
+};
+function aliasedSettings(config, checkDefinition) {
+    if (!checkDefinition.meta.aliases)
+        return undefined;
+    const usedAlias = checkDefinition.meta.aliases.find((alias) => config.checkSettings[alias]);
+    if (!usedAlias)
+        return undefined;
+    return config.checkSettings[usedAlias];
+}
+function unaliasedSettings(settings, checks) {
+    return Object.fromEntries(Object.entries(settings).map(([code, value]) => {
+        return [unaliasedCode(code, checks), value];
+    }));
+}
+function unaliasedCode(code, checks) {
+    const check = checks.find((check) => check.meta.code === code || check.meta.aliases?.find((alias) => alias === code));
+    return check?.meta.code;
+}
+async function isNodeModuleRoot(root) {
+    // is absolute absolute root
+    if (node_path_1.default.dirname(root) === root) {
+        return true;
+    }
+    const [isNodeModuleRoot, isGitRoot] = await Promise.all([
+        (0, file_utils_1.fileExists)(node_path_1.default.join(root, 'node_modules')),
+        (0, file_utils_1.fileExists)(node_path_1.default.join(root, '.git')),
+    ]);
+    return isNodeModuleRoot || isGitRoot;
+}
+async function findNodeModuleRoot(root) {
+    let curr = root;
+    while (!(await isNodeModuleRoot(curr))) {
+        curr = node_path_1.default.dirname(curr);
+    }
+    return curr;
+}
+//# sourceMappingURL=load-config-description.js.map

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

@@ -0,0 +1,18 @@
+import { Config } from '@platformos/platformos-check-common';
+import { AbsolutePath } from '../temp';
+import { ModernIdentifier } from './types';
+/**
+ * Given an absolute path to a config file, this function returns
+ * the validated Config object that it represents.
+ *
+ * In detail, it does the following:
+ *  - resolves and merges extended config,
+ *  - resolves the absolute path of the root,
+ *  - loads community-provided checks,
+ *  - validates check settings.
+ */
+export declare function loadConfig(
+/** The absolute path of config file */
+configPath: AbsolutePath | ModernIdentifier | undefined, 
+/** The root of the platformOS project */
+root: AbsolutePath): Promise<Config>;

package/dist/config/load-config.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const load_config_description_1 = require("./load-config-description");
+const resolve_1 = require("./resolve");
+const validation_1 = require("./validation");
+/**
+ * Given an absolute path to a config file, this function returns
+ * the validated Config object that it represents.
+ *
+ * In detail, it does the following:
+ *  - resolves and merges extended config,
+ *  - resolves the absolute path of the root,
+ *  - loads community-provided checks,
+ *  - validates check settings.
+ */
+async function loadConfig(
+/** The absolute path of config file */
+configPath, 
+/** The root of the platformOS project */
+root) {
+    if (!root)
+        throw new Error('loadConfig cannot be called without a root argument');
+    const defaultChecks = 'platformos-check:recommended';
+    const configDescription = await (0, resolve_1.resolveConfig)(configPath ?? defaultChecks, true);
+    const config = await (0, load_config_description_1.loadConfigDescription)(configDescription, root);
+    (0, validation_1.validateConfig)(config);
+    return config;
+}
+//# sourceMappingURL=load-config.js.map

package/dist/config/load-third-party-checks.d.ts

@@ -0,0 +1,16 @@
+import { CheckDefinition, SourceCodeType } from '@platformos/platformos-check-common';
+import { AbsolutePath } from '../temp';
+type ModulePath = string;
+export declare function loadThirdPartyChecks(
+/**
+ * An array of require()-able paths.
+ * @example
+ * [
+ *   '@acme/theme-check-extension',
+ *   '/absolute/path/to/checks.js',
+ *   './lib/checks.js',
+ * ]
+ * */
+modulePaths?: ModulePath[]): CheckDefinition<SourceCodeType>[];
+export declare function findThirdPartyChecks(nodeModuleRoot: AbsolutePath): Promise<ModulePath[]>;
+export {};

package/dist/config/load-third-party-checks.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadThirdPartyChecks = loadThirdPartyChecks;
+exports.findThirdPartyChecks = findThirdPartyChecks;
+const glob_1 = __importDefault(require("glob"));
+const node_util_1 = require("node:util");
+const asyncGlob = (0, node_util_1.promisify)(glob_1.default);
+function loadThirdPartyChecks(
+/**
+ * An array of require()-able paths.
+ * @example
+ * [
+ *   '@acme/theme-check-extension',
+ *   '/absolute/path/to/checks.js',
+ *   './lib/checks.js',
+ * ]
+ * */
+modulePaths = []) {
+    const checks = new Set();
+    for (const modulePath of modulePaths) {
+        try {
+            const moduleValue = require(/* webpackIgnore: true */ modulePath);
+            const moduleChecks = moduleValue.checks;
+            if (!Array.isArray(moduleChecks)) {
+                throw new Error(`Expected the 'checks' export to be an array and got ${typeof moduleChecks}`);
+            }
+            for (const check of moduleChecks) {
+                if (isCheckDefinition(check)) {
+                    checks.add(check);
+                }
+                else {
+                    console.error(`Expected ${check} to be a CheckDefinition, but it looks like it isn't`);
+                }
+            }
+        }
+        catch (e) {
+            console.error(`Error loading ${modulePath}, ignoring it.\n${e}`);
+        }
+    }
+    return [...checks];
+}
+async function findThirdPartyChecks(nodeModuleRoot) {
+    const paths = [
+        globJoin(nodeModuleRoot.replace(/\\/g, '/'), '/node_modules/theme-check-*/'),
+        globJoin(nodeModuleRoot.replace(/\\/g, '/'), '/node_modules/@*/theme-check-*/'),
+    ];
+    const results = await Promise.all(paths.map((path) => asyncGlob(path)));
+    return results
+        .flat()
+        .filter((x) => !/\@shopify\/theme-check-(node|common|browser|docs-updater)/.test(x) &&
+        !/theme-check-vscode/.test(x));
+}
+function globJoin(...parts) {
+    return parts.flatMap((x) => x.replace(/\\/g, '/').replace(/\/+$/, '')).join('/');
+}
+function isObjLiteral(thing) {
+    return thing !== null && typeof thing === 'object';
+}
+function isCheckDefinition(thing) {
+    return (isObjLiteral(thing) &&
+        'meta' in thing &&
+        'create' in thing &&
+        isObjLiteral(thing.meta) &&
+        'code' in thing.meta);
+}
+//# sourceMappingURL=load-third-party-checks.js.map

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

@@ -0,0 +1 @@
+export { resolveConfig } from './resolve-config';

package/dist/config/resolve/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = void 0;
+var resolve_config_1 = require("./resolve-config");
+Object.defineProperty(exports, "resolveConfig", { enumerable: true, get: function () { return resolve_config_1.resolveConfig; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,11 @@
+import { ConfigDescription, ConfigFragment } from '../types';
+/**
+ * Merges a set of ConfigDescription with a ConfigFragment to obtain a new ConfigDescription.
+ *
+ * Merge rules:
+ *   - The latest `root` is selected, it is not resolved ('./dist' remains './dist')
+ *   - `extends` becomes the empty array
+ *   - top level `ignore` is extended by concatenation
+ *   - checkSettings are deep merged
+ */
+export declare function mergeFragments(baseConfigs: ConfigDescription[], config: ConfigFragment): ConfigDescription;

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeFragments = mergeFragments;
+/**
+ * Merges a set of ConfigDescription with a ConfigFragment to obtain a new ConfigDescription.
+ *
+ * Merge rules:
+ *   - The latest `root` is selected, it is not resolved ('./dist' remains './dist')
+ *   - `extends` becomes the empty array
+ *   - top level `ignore` is extended by concatenation
+ *   - checkSettings are deep merged
+ */
+function mergeFragments(baseConfigs, config) {
+    return {
+        // we use the last one defined
+        root: selectLatest(baseConfigs.map((b) => b.root), config.root),
+        // when we're done, there's nothing left to extend
+        extends: [],
+        // we merge the ignore configs by concatenation
+        ignore: baseConfigs.flatMap((b) => b.ignore).concat(config.ignore),
+        // we merge the require configs by concatenation
+        require: baseConfigs.flatMap((b) => b.require).concat(config.require),
+        // we merge deep the settings
+        checkSettings: baseConfigs
+            .map((b) => b.checkSettings)
+            .concat(config.checkSettings)
+            .reduce(mergeDeep),
+        // We use the last one defined, or default to 'theme'
+        context: selectLatest(baseConfigs.map((b) => b.context), config.context) ?? 'theme',
+    };
+}
+function selectLatest(base, curr) {
+    return base.concat(curr).filter(Boolean).pop();
+}
+function mergeDeep(target, source) {
+    const output = { ...target };
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            if (isObject(target[key]) && isObject(source[key])) {
+                output[key] = mergeDeep(target[key], source[key]);
+            }
+            else {
+                output[key] = source[key];
+            }
+        }
+    }
+    return output;
+}
+function isObject(item) {
+    return item !== null && typeof item === 'object' && !Array.isArray(item);
+}
+//# sourceMappingURL=merge-fragments.js.map

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

@@ -0,0 +1,11 @@
+import { AbsolutePath } from '../../temp';
+import { ConfigFragment } from '../types';
+/**
+ * Takes an absolute path, parses the yaml at that path and turns it into a
+ * ConfigFragment object.
+ */
+export declare function readYamlConfigDescription(
+/** the absolute path to a .platformos-check.yml file */
+absolutePath: AbsolutePath, 
+/** only the root config has `extends: platformos-check:recommended` by default, it's nothing everywhere else */
+isRootConfig?: boolean): Promise<ConfigFragment>;