@sketch-hq/sketch-assistant-utils
Version:
Utility functions and types for Sketch Assistants.
195 lines (194 loc) • 7.01 kB
JavaScript
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 { createAssistantDefinition, createRule, createAssistant } from '../../test-helpers';
import { AssistantRuntime, } from '@sketch-hq/sketch-assistant-types';
import { prepare, assign } from '../';
describe('assign', () => {
test('names are merged right to left', () => {
expect(assign(createAssistantDefinition({
name: 'foo',
}), createAssistantDefinition({
name: 'bar',
})).name).toMatchInlineSnapshot(`"bar"`);
});
test('do not overwrite with values that are the empty string', () => {
expect(assign(createAssistantDefinition({
title: 'foo',
name: 'bar',
description: 'baz',
}), createAssistantDefinition({
title: '',
name: '',
description: '',
}))).toMatchInlineSnapshot(`
Object {
"config": Object {
"rules": Object {},
},
"name": "bar",
"rules": Array [],
}
`);
});
test('config is merged right to left', () => {
expect(assign(createAssistantDefinition({
config: {
rules: {
foo: { active: true },
},
},
}), createAssistantDefinition({
config: {
rules: {
foo: { active: false },
bar: { active: true },
},
},
})).config).toMatchInlineSnapshot(`
Object {
"rules": Object {
"bar": Object {
"active": true,
},
"foo": Object {
"active": false,
},
},
}
`);
});
test('rule config is merged right to left', () => {
expect(assign(createAssistantDefinition({
config: {
rules: {
foo: { active: true, foo: 1, bar: 'hello world!' },
},
},
}), createAssistantDefinition({
config: {
rules: {
foo: { active: true, bar: 'hello everyone!' },
},
},
})).config).toMatchInlineSnapshot(`
Object {
"rules": Object {
"foo": Object {
"active": true,
"bar": "hello everyone!",
"foo": 1,
},
},
}
`);
});
test('rules are concatenated', () => {
expect(assign(createAssistantDefinition({
rules: [createRule({ name: 'foo' })],
}), createAssistantDefinition({
rules: [createRule({ name: 'bar' })],
})).rules.map((rule) => rule.name)).toMatchInlineSnapshot(`
Array [
"foo",
"bar",
]
`);
});
});
describe('prepare', () => {
const env = {
locale: 'en',
runtime: AssistantRuntime.Sketch,
};
test('prepares a single assistant function', () => __awaiter(void 0, void 0, void 0, function* () {
const assistant = yield prepare(createAssistant(), env);
expect(assistant.name).toMatchInlineSnapshot(`"dummy-assistant"`);
}));
test('prepares and merges multiple assistant functions', () => __awaiter(void 0, void 0, void 0, function* () {
const assistant = yield prepare([
createAssistant({ rules: [createRule({ name: 'foo' })] }),
createAssistant({ rules: [createRule({ name: 'bar' })] }),
], env);
expect(assistant.rules.map((rule) => rule.name)).toMatchInlineSnapshot(`
Array [
"foo",
"bar",
]
`);
}));
test('prepares and merges nested assistant functions', () => __awaiter(void 0, void 0, void 0, function* () {
const assistant = yield prepare([
createAssistant({ rules: [createRule({ name: 'foo' })] }),
[
createAssistant({ rules: [createRule({ name: 'bar' })] }),
createAssistant({ rules: [createRule({ name: 'baz' })] }),
],
createAssistant({ rules: [createRule({ name: 'qux' })] }),
], env);
expect(assistant.rules.map((rule) => rule.name)).toMatchInlineSnapshot(`
Array [
"foo",
"bar",
"baz",
"qux",
]
`);
}));
test('assistants can init lazily and do work during preparation', () => __awaiter(void 0, void 0, void 0, function* () {
const assistant = yield prepare(() => __awaiter(void 0, void 0, void 0, function* () {
const def = createAssistantDefinition();
def.name = 'bar';
return def;
}), env);
expect(assistant.name).toMatchInlineSnapshot(`"bar"`);
}));
test('handles assistants containing ESM default exports', () => __awaiter(void 0, void 0, void 0, function* () {
const assistant = yield prepare([
{ __esModule: true, default: createAssistant({ rules: [createRule({ name: 'foo' })] }) },
[
createAssistant({ rules: [createRule({ name: 'bar' })] }),
{ __esModule: true, default: createAssistant({ rules: [createRule({ name: 'baz' })] }) },
],
createAssistant({ rules: [createRule({ name: 'qux' })] }),
], env);
expect(assistant.rules.map((rule) => rule.name)).toMatchInlineSnapshot(`
Array [
"foo",
"bar",
"baz",
"qux",
]
`);
}));
test('handles assistants themselves exported as ESM default exports', () => __awaiter(void 0, void 0, void 0, function* () {
const assistant = yield prepare({
__esModule: true,
default: [
{ __esModule: true, default: createAssistant({ rules: [createRule({ name: 'foo' })] }) },
[
createAssistant({ rules: [createRule({ name: 'bar' })] }),
{
__esModule: true,
default: createAssistant({ rules: [createRule({ name: 'baz' })] }),
},
],
createAssistant({ rules: [createRule({ name: 'qux' })] }),
],
}, env);
expect(assistant.rules.map((rule) => rule.name)).toMatchInlineSnapshot(`
Array [
"foo",
"bar",
"baz",
"qux",
]
`);
}));
});