@sprucelabs/spruce-templates 22.1.13 → 22.2.0

package/build/esm/addons/isDefined.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/isDefined.addon.js

@@ -0,0 +1,5 @@
+import handlebars from 'handlebars';
+/* Quick way to do an equals check against 2 values */
+handlebars.registerHelper('isDefined', function (value) {
+    return value !== undefined;
+});

package/build/esm/addons/json.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/json.addon.js

@@ -0,0 +1,7 @@
+import handlebars from 'handlebars';
+/* Quick way to do an equals check against 2 values */
+handlebars.registerHelper('json', function (arg1) {
+    //@ts-ignore // TODO how should this work in a typed environment?
+    const value = JSON.stringify(arg1);
+    return value;
+});

package/build/esm/addons/neq.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/neq.addon.js

@@ -0,0 +1,4 @@
+import handlebars from 'handlebars';
+handlebars.registerHelper('neq', (val1, val2) => {
+    return val1 !== val2;
+});

package/build/esm/addons/operators.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/operators.addon.js

@@ -0,0 +1,15 @@
+import handlebars from 'handlebars';
+handlebars.registerHelper({
+    eq: (v1, v2) => v1 === v2,
+    ne: (v1, v2) => v1 !== v2,
+    lt: (v1, v2) => v1 < v2,
+    gt: (v1, v2) => v1 > v2,
+    lte: (v1, v2) => v1 <= v2,
+    gte: (v1, v2) => v1 >= v2,
+    and(...params) {
+        return Array.prototype.every.call(params, Boolean);
+    },
+    or(...params) {
+        return Array.prototype.slice.call(params, 0, -1).some(Boolean);
+    },
+});

package/build/esm/addons/pascalCase.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/pascalCase.addon.js

@@ -0,0 +1,6 @@
+import handlebars from 'handlebars';
+import { upperFirst } from 'lodash';
+/* Start case (cap first letter, lower rest) */
+handlebars.registerHelper('pascalCase', (val) => {
+    return upperFirst(val);
+});

package/build/esm/addons/permissionContractBuilder.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/permissionContractBuilder.addon.js

@@ -0,0 +1,4 @@
+import handlebars from 'handlebars';
+handlebars.registerHelper('permissionContractBuilder', function (permissionContract) {
+    return `buildPermissionContract(${JSON.stringify(permissionContract, null, 2)})`;
+});

package/build/esm/addons/schemaBodyPartial.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/schemaBodyPartial.addon.js

@@ -0,0 +1,8 @@
+import path from 'path';
+import fs from 'fs-extra';
+import handlebars from 'handlebars';
+const templatePath = path.join(__dirname, '..', 'templates', 'typescript');
+const schemaBodyPartial = fs
+    .readFileSync(path.join(templatePath, 'schema/partials/schemaBody.ts.hbs'))
+    .toString();
+handlebars.registerPartial('schemaBody', schemaBodyPartial);

package/build/esm/addons/schemaNamespacePath.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/schemaNamespacePath.addon.js

@@ -0,0 +1,18 @@
+import handlebars from 'handlebars';
+handlebars.registerHelper('schemaNamespacePath', function (options) {
+    var _a, _b;
+    const { schemaTemplateItem } = options.hash;
+    if (!schemaTemplateItem) {
+        throw new Error(`schemaNamespacePath needs schemaTemplateItem=item`);
+    }
+    const { globalSchemaNamespace } = (_b = (_a = options === null || options === void 0 ? void 0 : options.data) === null || _a === void 0 ? void 0 : _a.root) !== null && _b !== void 0 ? _b : {};
+    if (!globalSchemaNamespace) {
+        throw new Error('schemaNamespacePath template addon needs globalSchemaNamespace in the root context.');
+    }
+    let path = `${globalSchemaNamespace}.${schemaTemplateItem.namespace}`;
+    if (schemaTemplateItem.schema.version) {
+        path += `.${schemaTemplateItem.schema.version}`;
+    }
+    path += `.${schemaTemplateItem.namePascal}`;
+    return path;
+});

package/build/esm/addons/schemaValuesPartial.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/schemaValuesPartial.addon.js

@@ -0,0 +1,8 @@
+import path from 'path';
+import fs from 'fs-extra';
+import handlebars from 'handlebars';
+const templatePath = path.join(__dirname, '..', 'templates', 'typescript');
+const schemaValuesPartial = fs
+    .readFileSync(path.join(templatePath, 'schema/partials/schemaValues.ts.hbs'))
+    .toString();
+handlebars.registerPartial('schemaValues', schemaValuesPartial);

package/build/esm/addons/valueTypeGenerator.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/valueTypeGenerator.addon.js

@@ -0,0 +1,15 @@
+import handlebars from 'handlebars';
+import { upperFirst } from 'lodash';
+handlebars.registerHelper('valueTypeGenerator', function (fieldDefinition, renderAs, func, options) {
+    const { data: { root: { fieldTemplateItems }, }, } = options;
+    const match = fieldTemplateItems.filter((item) => item.camelType === fieldDefinition.type)[0];
+    if (!match) {
+        throw new Error(`valueTypeGenerator.addon could not find a fieldTemplateItem with type ${fieldDefinition.type}`);
+    }
+    const type = handlebars.helpers.fieldTypeEnum(fieldDefinition, options);
+    const fieldDefinitionCopy = Object.assign({}, fieldDefinition);
+    // @ts-ignore
+    fieldDefinitionCopy === null || fieldDefinitionCopy === void 0 ? true : delete fieldDefinitionCopy.keyName;
+    const def = JSON.stringify(Object.assign(Object.assign({}, fieldDefinitionCopy), { type: '{{TYPE_ENUM}}' })).replace('"{{TYPE_ENUM}}"', type);
+    return `${func}(${def}, TemplateRenderAs.${upperFirst(renderAs)}, "${match.importAs}")`;
+});

package/build/esm/addons/valueTypeLiteral.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/valueTypeLiteral.addon.js

@@ -0,0 +1,32 @@
+import { TemplateRenderAs } from '@sprucelabs/schema';
+import { SCHEMA_VERSION_FALLBACK } from '@sprucelabs/spruce-skill-utils';
+import handlebars from 'handlebars';
+/* The type for the value of a field. the special case is if the field is of type schema, then we get the target's interface */
+handlebars.registerHelper('valueTypeLiteral', function (namespace, nameCamel, version, fieldName, renderAs, options) {
+    var _a, _b, _c, _d;
+    if (!namespace) {
+        throw new Error('valueTypeLiteral needs namespace as 1st argument');
+    }
+    if (!nameCamel) {
+        throw new Error('valueTypeLiteral needs nameCamel as 2st argument');
+    }
+    if (!fieldName) {
+        throw new Error('valueTypeLiteral needs fieldName as 3st argument');
+    }
+    if (renderAs !== TemplateRenderAs.Value &&
+        renderAs !== TemplateRenderAs.Type &&
+        renderAs !== TemplateRenderAs.SchemaType) {
+        throw new Error('valueTypeLiteral helper needs renderAs to be "TemplateRenderAs.Type" or "TemplateRenderAs.Value" or "TemplateRenderAs.schemaType"');
+    }
+    const { data: { root }, } = options;
+    const valueTypes = root === null || root === void 0 ? void 0 : root.valueTypes;
+    if (!valueTypes) {
+        throw new Error('valueTypeLiteral helper needs a valuesTypes in the root context');
+    }
+    const v = version ? version : SCHEMA_VERSION_FALLBACK;
+    const valueType = (_d = (_c = (_b = (_a = valueTypes[namespace]) === null || _a === void 0 ? void 0 : _a[nameCamel]) === null || _b === void 0 ? void 0 : _b[v]) === null || _c === void 0 ? void 0 : _c[fieldName]) === null || _d === void 0 ? void 0 : _d.valueTypes[renderAs];
+    if (!valueType) {
+        throw new Error(`Unable to render value type for field "${namespace}.${nameCamel}.${v}.${fieldName}"`);
+    }
+    return valueType;
+});

package/build/esm/addons/valueTypeMapper.addon.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/addons/valueTypeMapper.addon.js

@@ -0,0 +1,9 @@
+import handlebars from 'handlebars';
+handlebars.registerHelper('valueTypeMapper', function (typeMapper, renderAs) {
+    if (renderAs === 'typeOnly') {
+        return typeMapper.split('<')[0];
+    }
+    else {
+        return typeMapper;
+    }
+});

package/build/esm/index.d.ts

@@ -0,0 +1,138 @@
+import { PermissionContractMap } from '@sprucelabs/mercury-types';
+import { Schema, SchemaTemplateItem, FieldTemplateItem } from '@sprucelabs/schema';
+import { TemplateRenderAs } from '@sprucelabs/schema';
+import handlebars from 'handlebars';
+import { FieldDefinitions } from '#spruce/schemas/fields/fields.types';
+import { DirectoryTemplateCode, DirectoryTemplateContextMap, ValueTypes, SchemaBuilderTemplateItem, ErrorOptions, ErrorTemplateItem, TestOptions, EventListenerOptions, EventContractTemplateItem, EventPayloadOptions, StoreTemplateOptions, StoreTemplateItem, ViewsOptions as CombinedViewsOptions, ListenerTemplateItem } from './types/templates.types';
+import './addons';
+export declare const templates: {
+    schemasTypes(options: {
+        schemaTemplateItems: SchemaTemplateItem[];
+        fieldTemplateItems: FieldTemplateItem[];
+        valueTypes: ValueTypes;
+        globalSchemaNamespace?: string;
+        typesTemplate?: string;
+    }): string;
+    valueTypes(options: {
+        schemaTemplateItems: SchemaTemplateItem[];
+        fieldTemplateItems: FieldTemplateItem[];
+        globalSchemaNamespace?: string;
+    }): string;
+    schema(options: SchemaTemplateItem & {
+        schemaTemplateItems: SchemaTemplateItem[];
+        fieldTemplateItems: FieldTemplateItem[];
+        valueTypes: ValueTypes;
+        globalSchemaNamespace?: string;
+        registerBuiltSchemas: boolean;
+        schemaFile?: string;
+        typesFile?: string;
+    }): string;
+    schemaBuilder(options: SchemaBuilderTemplateItem): string;
+    error(options: ErrorOptions): string;
+    errorOptionsTypes(options: {
+        options: ErrorTemplateItem[];
+    }): string;
+    schemaExample(options: {
+        nameCamel: string;
+        namePascal: string;
+        definition: Schema;
+    }): string;
+    schemaPlugin(): string;
+    errorPlugin(): string;
+    conversationPlugin(): string;
+    deployPlugin(): string;
+    errorExample(options: {
+        nameCamel: string;
+        namePascal: string;
+        definition: Schema;
+    }): string;
+    test(options: TestOptions): string;
+    fieldsTypes(options: {
+        fieldTemplateItems: FieldTemplateItem[];
+    }): string;
+    fieldClassMap(options: {
+        fieldTemplateItems: FieldTemplateItem[];
+    }): string;
+    launchConfig(): string;
+    vsCodeSettings(): Promise<string>;
+    listener(options: EventListenerOptions): string;
+    listeners(options: {
+        listeners: ListenerTemplateItem[];
+    }): string;
+    eventContract(options: EventContractTemplateItem & {
+        schemaTemplateItems: SchemaTemplateItem[];
+    }): string;
+    eventOptions(options: {
+        isGlobal: boolean;
+    }): string;
+    permissionPlugin(): string;
+    permissions(options: {
+        contracts: {
+            path: string;
+            nameCamel: string;
+        }[];
+    }): string;
+    permissionContractBuilder(options: {
+        nameCamel: string;
+        nameKebab: string;
+        nameReadable: string;
+        description?: string;
+    }): string;
+    permissionTypes(options: {
+        contracts: PermissionContractMap;
+    }): string;
+    eventEmitPayload(options: EventPayloadOptions): string;
+    eventEmitTarget(options: EventPayloadOptions): string;
+    eventResponsePayload(options: EventPayloadOptions): string;
+    combinedEventsContract(options: {
+        templateItems: EventContractTemplateItem[];
+        shouldImportCoreEvents?: boolean;
+        skillEventContractTypesFile: string;
+    }): string;
+    sandboxWillBootListener(): string;
+    polish(): string;
+    directoryTemplate<K extends DirectoryTemplateCode>(options: {
+        kind: K;
+        context: DirectoryTemplateContextMap[K];
+    }): Promise<(import("./types/templates.types").DirectoryTemplateFile & {
+        contents: string;
+    })[]>;
+    isValidTemplatedDirectory(options: {
+        kind: DirectoryTemplateCode;
+        dir: string;
+    }): Promise<boolean>;
+    conversationTopic(options: {
+        nameReadable: string;
+    }): string;
+    generateFieldKey(renderAs: TemplateRenderAs, definition: FieldDefinitions): string;
+    storePlugin(): string;
+    store(options: StoreTemplateOptions): string;
+    storeTypes(options: {
+        stores: StoreTemplateItem[];
+    }): string;
+    stores(options: {
+        stores: StoreTemplateItem[];
+    }): string;
+    skillViewController(options: {
+        namePascal: string;
+        nameKebab: string;
+    }): string;
+    viewController(options: {
+        viewModel: string;
+        namePascal: string;
+        nameKebab: string;
+    }): string;
+    appViewController(): string;
+    views(options: CombinedViewsOptions): string;
+    viewPlugin(): string;
+    viewControllerPlugin(options: {
+        namePascal: string;
+        nameCamel: string;
+    }): string;
+    theme(): string;
+    logTransport(): string;
+};
+export type Templates = typeof templates;
+export { default as importExtractorUtil } from './utilities/importExtractor.utility';
+export default handlebars;
+export * from './types/templates.types';

package/build/esm/index.js

@@ -0,0 +1,255 @@
+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 fs from 'fs';
+import path from 'path';
+import { TemplateRenderAs } from '@sprucelabs/schema';
+import { SCHEMA_VERSION_FALLBACK, DEFAULT_GLOBAL_SCHEMA_NAMESPACE, DEFAULT_BUILDER_FUNCTION, DEFAULT_SCHEMA_TYPES_FILE, } from '@sprucelabs/spruce-skill-utils';
+import handlebars from 'handlebars';
+import { DirectoryTemplateCode, } from './types/templates.types';
+import DirectoryTemplateUtility from './utilities/DirectoryTemplateUtility';
+import importExtractorUtil from './utilities/importExtractor.utility';
+import KeyGeneratorUtility from './utilities/KeyGeneratorUtility';
+import templateImportUtil from './utilities/templateImporter.utility';
+import templateItemUtil from './utilities/templateItem.utility';
+// Manual import of addons for Bun
+import './addons';
+// addonUtil.importSync({}, __dirname, 'addons')
+export const templates = {
+    schemasTypes(options) {
+        var _a, _b;
+        const imports = importExtractorUtil.extractFieldImports(options.fieldTemplateItems);
+        const template = templateImportUtil.getTemplate((_a = options.typesTemplate) !== null && _a !== void 0 ? _a : 'schema/schemas.types.ts.hbs');
+        const schemaImports = importExtractorUtil.extractSchemaImports(options.schemaTemplateItems);
+        return template(Object.assign(Object.assign({}, options), { imports,
+            schemaImports, globalSchemaNamespace: (_b = options.globalSchemaNamespace) !== null && _b !== void 0 ? _b : DEFAULT_GLOBAL_SCHEMA_NAMESPACE }));
+    },
+    valueTypes(options) {
+        var _a;
+        const imports = importExtractorUtil.extractFieldImports(options.fieldTemplateItems);
+        const rendersAs = Object.values(TemplateRenderAs);
+        const schemaTemplatesByNamespaceAndName = templateItemUtil.groupSchemaTemplatesByNamespaceAndName(options.schemaTemplateItems);
+        const fieldTemplatesByType = templateItemUtil.groupFieldItemsByNamespace(options.fieldTemplateItems);
+        const template = templateImportUtil.getTemplate('schema/valueTypes.ts.hbs');
+        return template(Object.assign(Object.assign({}, options), { imports,
+            fieldTemplatesByType,
+            schemaTemplatesByNamespaceAndName,
+            SCHEMA_VERSION_FALLBACK,
+            rendersAs, globalSchemaNamespace: (_a = options.globalSchemaNamespace) !== null && _a !== void 0 ? _a : DEFAULT_GLOBAL_SCHEMA_NAMESPACE }));
+    },
+    schema(options) {
+        var _a, _b, _c;
+        const imports = importExtractorUtil.extractFieldImports(options.fieldTemplateItems);
+        const template = templateImportUtil.getTemplate((_a = options.schemaFile) !== null && _a !== void 0 ? _a : 'schema/schema.ts.hbs');
+        return template(Object.assign(Object.assign({}, options), { imports, globalSchemaNamespace: (_b = options.globalSchemaNamespace) !== null && _b !== void 0 ? _b : DEFAULT_GLOBAL_SCHEMA_NAMESPACE, typesFile: (_c = options.typesFile) !== null && _c !== void 0 ? _c : DEFAULT_SCHEMA_TYPES_FILE }));
+    },
+    schemaBuilder(options) {
+        var _a;
+        const template = templateImportUtil.getTemplate('schema/builder.ts.hbs');
+        return template(Object.assign(Object.assign({}, options), { builderFunction: (_a = options.builderFunction) !== null && _a !== void 0 ? _a : DEFAULT_BUILDER_FUNCTION }));
+    },
+    error(options) {
+        const template = templateImportUtil.getTemplate('error/SpruceError.ts.hbs');
+        return template(Object.assign({ renderClassDefinition: true }, options));
+    },
+    errorOptionsTypes(options) {
+        const template = templateImportUtil.getTemplate('error/options.types.ts.hbs');
+        return template(options);
+    },
+    schemaExample(options) {
+        const template = templateImportUtil.getTemplate('schema/example.ts.hbs');
+        return template(options);
+    },
+    schemaPlugin() {
+        const template = templateImportUtil.getTemplate('schema/schema.plugin.ts.hbs');
+        return template({});
+    },
+    errorPlugin() {
+        const template = templateImportUtil.getTemplate('error/error.plugin.ts.hbs');
+        return template({});
+    },
+    conversationPlugin() {
+        const template = templateImportUtil.getTemplate('conversation/conversation.plugin.ts.hbs');
+        return template({});
+    },
+    deployPlugin() {
+        const template = templateImportUtil.getTemplate('deploy/deploy.plugin.ts.hbs');
+        return template({});
+    },
+    errorExample(options) {
+        const template = templateImportUtil.getTemplate('error/example.ts.hbs');
+        return template(options);
+    },
+    test(options) {
+        const template = templateImportUtil.getTemplate('test/Test.test.ts.hbs');
+        return template(options);
+    },
+    fieldsTypes(options) {
+        const template = templateImportUtil.getTemplate('schema/fields/fields.types.ts.hbs');
+        return template(options);
+    },
+    fieldClassMap(options) {
+        const template = templateImportUtil.getTemplate('schema/fields/fieldClassMap.ts.hbs');
+        return template(options);
+    },
+    launchConfig() {
+        const template = templateImportUtil.getTemplate('vscode/launch.json');
+        return template({});
+    },
+    vsCodeSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const files = yield templates.directoryTemplate({
+                kind: DirectoryTemplateCode.VsCode,
+                context: {},
+            });
+            const settings = files.find((f) => f.filename === 'settings.json');
+            return settings.contents;
+        });
+    },
+    listener(options) {
+        const template = templateImportUtil.getTemplate('event/listener.ts.hbs');
+        return template(Object.assign(Object.assign({ globalSchemaNamespace: DEFAULT_GLOBAL_SCHEMA_NAMESPACE }, options), { shouldImportGlobalSchema: options.emitPayloadSchemaTemplateItem ||
+                options.responsePayloadSchemaTemplateItem }));
+    },
+    listeners(options) {
+        const template = templateImportUtil.getTemplate('event/listeners.ts.hbs');
+        return template(Object.assign({}, options));
+    },
+    eventContract(options) {
+        const template = templateImportUtil.getTemplate('event/event.contract.ts.hbs');
+        return template(options);
+    },
+    eventOptions(options) {
+        const template = templateImportUtil.getTemplate('event/event.options.ts.hbs');
+        return template(Object.assign(Object.assign({}, options), { isGlobal: options.isGlobal ? 'true' : 'false' }));
+    },
+    permissionPlugin() {
+        const template = templateImportUtil.getTemplate('permissions/permission.plugin.ts.hbs');
+        return template({});
+    },
+    permissions(options) {
+        const template = templateImportUtil.getTemplate('permissions/permissions.ts.hbs');
+        return template(Object.assign({}, options));
+    },
+    permissionContractBuilder(options) {
+        const template = templateImportUtil.getTemplate('permissions/contract.builder.ts.hbs');
+        return template(options);
+    },
+    permissionTypes(options) {
+        const template = templateImportUtil.getTemplate('permissions/permissions.types.ts.hbs');
+        return template(options);
+    },
+    eventEmitPayload(options) {
+        const template = templateImportUtil.getTemplate('event/payload.builder.ts.hbs');
+        return template(Object.assign(Object.assign({}, options), { actionCamel: 'EmitPayload' }));
+    },
+    eventEmitTarget(options) {
+        const template = templateImportUtil.getTemplate('event/payload.builder.ts.hbs');
+        return template(Object.assign(Object.assign({}, options), { actionCamel: 'EmitTarget' }));
+    },
+    eventResponsePayload(options) {
+        const template = templateImportUtil.getTemplate('event/payload.builder.ts.hbs');
+        return template(Object.assign(Object.assign({}, options), { actionCamel: 'ResponsePayload' }));
+    },
+    combinedEventsContract(options) {
+        const template = templateImportUtil.getTemplate('event/events.contract.ts.hbs');
+        return template(Object.assign(Object.assign({}, options), { contracts: options.templateItems }));
+    },
+    sandboxWillBootListener() {
+        const template = templateImportUtil.getTemplate('sandbox/will-boot.listener.ts.hbs');
+        return template({});
+    },
+    polish() {
+        const template = templateImportUtil.getTemplate('polish/polish.ts.hbs');
+        return template({});
+    },
+    directoryTemplate(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return DirectoryTemplateUtility.build(options);
+        });
+    },
+    isValidTemplatedDirectory(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { kind, dir } = options;
+            if (kind === DirectoryTemplateCode.Skill) {
+                return fs.existsSync(path.join(dir, 'package.json'));
+            }
+            const filesToCheck = yield DirectoryTemplateUtility.filesInTemplate(kind);
+            let filesMissing = false;
+            for (const file of filesToCheck) {
+                if (!fs.existsSync(file.path)) {
+                    filesMissing = true;
+                    break;
+                }
+            }
+            if (!filesMissing) {
+                return true;
+            }
+            return false;
+        });
+    },
+    conversationTopic(options) {
+        const template = templateImportUtil.getTemplate('conversation/conversation.topic.ts.hbs');
+        return template(options);
+    },
+    generateFieldKey(renderAs, definition) {
+        return KeyGeneratorUtility.generateFieldKey(renderAs, definition);
+    },
+    storePlugin() {
+        const template = templateImportUtil.getTemplate('store/store.plugin.ts.hbs');
+        return template({});
+    },
+    store(options) {
+        const template = templateImportUtil.getTemplate('store/Store.store.ts.hbs');
+        return template(options);
+    },
+    storeTypes(options) {
+        const template = templateImportUtil.getTemplate('store/stores.types.ts.hbs');
+        return template(options);
+    },
+    stores(options) {
+        const template = templateImportUtil.getTemplate('store/stores.ts.hbs');
+        return template(options);
+    },
+    skillViewController(options) {
+        const template = templateImportUtil.getTemplate('view/View.svc.ts.hbs');
+        return template(options);
+    },
+    viewController(options) {
+        const template = templateImportUtil.getTemplate('view/View.vc.ts.hbs');
+        return template(options);
+    },
+    appViewController() {
+        const template = templateImportUtil.getTemplate('view/App.avc.ts.hbs');
+        return template({});
+    },
+    views(options) {
+        const template = templateImportUtil.getTemplate('view/views.ts.hbs');
+        return template(options);
+    },
+    viewPlugin() {
+        const template = templateImportUtil.getTemplate('view/view.plugin.ts.hbs');
+        return template({});
+    },
+    viewControllerPlugin(options) {
+        const template = templateImportUtil.getTemplate('view/viewController.plugin.ts.hbs');
+        return template(options);
+    },
+    theme() {
+        const template = templateImportUtil.getTemplate('view/skill.theme.ts.hbs');
+        return template({});
+    },
+    logTransport() {
+        const template = templateImportUtil.getTemplate('log/transport.plugin.ts.hbs');
+        return template({});
+    },
+};
+export { default as importExtractorUtil } from './utilities/importExtractor.utility';
+export default handlebars;
+export * from './types/templates.types';

package/build/esm/templates/directories/skill/.nvmrc

@@ -0,0 +1 @@
+lts/*

package/build/esm/templates/directories/skill/README.md

@@ -0,0 +1,4 @@
+# [Your Skill Name]
+
+## Useful links
+* [Spruce Developer Documentation: https://developer.spruce.ai](https://developer.spruce.ai)

package/build/esm/templates/directories/skill/eslint.config.mjs

@@ -0,0 +1,3 @@
+import eslintConfigSpruce from 'eslint-config-spruce'
+
+export default eslintConfigSpruce

package/build/esm/templates/directories/skill/package.json.hbs

@@ -0,0 +1,15 @@
+{
+	"name": "{{name}}",
+	"description": "{{description}}",
+	"version": "0.0.1",
+	"skill": {},
+	"homepage": "https://github.com/[YOUR REPO PATH]",
+	"bugs": {
+		"url": "https://github.com/[YOUR REPO PATH]/issues"
+	},
+	"keywords": [],
+	"scripts": {},
+	"dependencies": {},
+	"devDependencies": {
+	}
+}

package/build/esm/templates/directories/skill/src/.spruce/errors/options.types.ts

@@ -0,0 +1,6 @@
+interface ErrorOptions {
+    code: 'NO_ERRORS_CREATED'
+    friendlyMessage?: string
+}
+
+export default ErrorOptions

package/build/esm/templates/directories/skill/src/.spruce/features/event.plugin.ts

@@ -0,0 +1 @@
+export { plugin as default } from '@sprucelabs/spruce-event-plugin'

package/build/esm/templates/directories/skill/src/.spruce/skill.ts

@@ -0,0 +1,8 @@
+import pathUtil from 'path'
+import Skill from '@sprucelabs/spruce-skill-booter'
+
+export default new Skill({
+    rootDir: pathUtil.join(__dirname, '..', '..'),
+    activeDir: pathUtil.join(__dirname, '..'),
+    hashSpruceDir: pathUtil.join(__dirname, '..', '.spruce'),
+})

package/build/esm/templates/directories/skill/src/errors/SpruceError.ts.hbs

@@ -0,0 +1,20 @@
+import AbstractSpruceError from '@sprucelabs/error'
+import ErrorOptions from '#spruce/errors/options.types'
+
+export default class SpruceError extends AbstractSpruceError<ErrorOptions> {
+    public friendlyMessage(): string {
+        const { options } = this
+        let message
+
+        switch (options?.code) {
+            default:
+                message = super.friendlyMessage()
+        }
+
+        const fullMessage = options.friendlyMessage
+            ? options.friendlyMessage
+            : message
+
+        return fullMessage
+    }
+}