@sketch-hq/sketch-assistant-utils/dist/esm/test-helpers/index.js

Utility functions and types for Sketch Assistants.

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { AssistantRuntime, } from '@sketch-hq/sketch-assistant-types';
import { fromFile } from '@sketch-hq/sketch-file';
import { getRuleDefinition, prepare } from '../assistant';
import { getImageMetadata } from '../get-image-metadata';
import { process } from '../process';
import { runAssistant } from '../run/run-assistant';
/**
 * Create a dummy rule definition.
 */
const createRule = ({ title, description, rule, getOptions, name, debug, runtime, } = {}) => ({
    name: name !== null && name !== void 0 ? name : 'dummy-assistant/dummy-rule',
    title: title !== null && title !== void 0 ? title : 'Dummy Rule',
    description: description !== null && description !== void 0 ? description : 'Dummy rule created in a test helper',
    rule: rule || (() => __awaiter(void 0, void 0, void 0, function* () { })),
    getOptions,
    debug,
    runtime,
});
/**
 * Create a dummy assistant configuration.
 */
const createAssistantConfig = ({ rules, defaultSeverity, } = {}) => (Object.assign(Object.assign({}, (typeof defaultSeverity === 'undefined' ? {} : { defaultSeverity })), { rules: rules || {} }));
/**
 * Create a dummy assistant definition.
 */
const createAssistantDefinition = ({ name, config, rules, } = {}) => ({
    name: name !== null && name !== void 0 ? name : 'dummy-assistant',
    config: config || createAssistantConfig(),
    rules: rules || [],
});
/**
 * Create a dummy assistant function.
 */
const createAssistant = ({ title, description, name, config, rules, } = {}) => () => __awaiter(void 0, void 0, void 0, function* () { return createAssistantDefinition({ title, description, name, config, rules }); });
const createDummyRect = () => ({
    _class: 'rect',
    constrainProportions: false,
    height: 10,
    width: 10,
    x: 0,
    y: 0,
});
const createDummySwatch = (id = '1') => ({
    _class: 'swatch',
    do_objectID: id,
    name: 'dummy-swatch',
    value: {
        _class: 'color',
        alpha: 1,
        red: 1,
        blue: 1,
        green: 1,
    },
});
/**
 * Test an Assistant.
 */
const testAssistant = (filepath, assistant, env = { locale: 'en', runtime: AssistantRuntime.Node }) => __awaiter(void 0, void 0, void 0, function* () {
    const file = yield fromFile(filepath);
    const op = { cancelled: false };
    const processedFile = yield process(file, op);
    const def = yield prepare(assistant, env);
    const { violations, ruleErrors, grade } = yield runAssistant(processedFile, def, env, op, getImageMetadata, { pages: [], assistants: {} }, Infinity);
    return { violations, ruleErrors, grade };
});
/**
 * Test a rule by running it against a custom config within the context of a
 * temporary Assistant.
 */
const testRule = (filepath, rule, ruleConfig = { active: true }, env = { locale: 'en', runtime: AssistantRuntime.Node }) => __awaiter(void 0, void 0, void 0, function* () {
    const file = yield fromFile(filepath);
    const op = { cancelled: false };
    const processedFile = yield process(file, op);
    const assistant = () => __awaiter(void 0, void 0, void 0, function* () {
        return ({
            name: 'test-assistant',
            rules: [rule],
            config: {
                rules: {
                    [rule.name]: ruleConfig,
                },
            },
        });
    });
    const def = yield prepare(assistant, env);
    const { violations, ruleErrors, grade } = yield runAssistant(processedFile, def, env, op, getImageMetadata, { pages: [], assistants: {} }, Infinity);
    return { violations, ruleErrors, grade };
});
/**
 * Test a rule in isolation within the context of an Assistant. Only the rule under test is
 * activated, so violations or rule errors from other rules are ignored. A custom rule config can
 * be supplied, but if omitted the config currently configured in the Assistant is used.
 */
const testRuleInAssistant = (filepath, assistant, ruleName, ruleConfig, env = { locale: 'en', runtime: AssistantRuntime.Node }) => __awaiter(void 0, void 0, void 0, function* () {
    const file = yield fromFile(filepath);
    const op = { cancelled: false };
    const processedFile = yield process(file, op);
    const def = yield prepare(assistant, env);
    def.rules = def.rules.filter((rule) => rule.name === ruleName);
    if (!getRuleDefinition(def, ruleName)) {
        throw new Error(`Rule "${ruleName}" not found on Assistant "${def.name}"`);
    }
    def.config.rules = {
        [ruleName]: ruleConfig ? ruleConfig : def.config.rules[ruleName],
    };
    const { violations, ruleErrors, grade } = yield runAssistant(processedFile, def, env, op, getImageMetadata, { pages: [], assistants: {} }, Infinity);
    return { violations, ruleErrors, grade };
});
export { createRule, createDummyRect, createDummySwatch, createAssistantConfig, createAssistant, createAssistantDefinition, testRule, testRuleInAssistant, testAssistant, };