@sprucelabs/spruce-cli 20.0.5 → 21.0.0

package/build/__tests__/behavioral/schemas/SettingUpSchemasForModuleDistribution.test.js

@@ -1,738 +1,407 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
-var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _applyDecoratedDescriptor2 = _interopRequireDefault(require("@babel/runtime/helpers/applyDecoratedDescriptor"));
-var _spruceSkillUtils = require("@sprucelabs/spruce-skill-utils");
-var _testUtils = require("@sprucelabs/test-utils");
-var _SchemaTemplateItemBuilder = _interopRequireDefault(require("../../../templateItemBuilders/SchemaTemplateItemBuilder"));
-var _AbstractSkillTest2 = _interopRequireDefault(require("../../../tests/AbstractSkillTest"));
-var _test = _interopRequireDefault(require("../../../tests/utilities/test.utility"));
-var _dec, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec10, _dec11, _dec12, _dec13, _dec14, _dec15, _class, _SettingUpSchemasForModuleDistributionTest;
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
-var LOCAL_NAMESPACE = 'TestingSchemas';
-var REMOTE_NAMESPACE = 'RemoteSchemas';
-var REMOTE_MODULE = '@sprucelabs/calendar-utils';
-var REMOTE_MODULE2 = '@sprucelabs/spruce-templates';
-var SettingUpSchemasForModuleDistributionTest = exports["default"] = (_dec = (0, _testUtils.test)('can specify importFromModuleWhenRemote 1', 'CalendarEvent', REMOTE_MODULE, '1'), _dec2 = (0, _testUtils.test)('can specify importFromModuleWhenRemote 2', 'CalendarEvent2', REMOTE_MODULE2, '2'), _dec3 = (0, _testUtils.test)(), _dec4 = (0, _testUtils.test)(), _dec5 = (0, _testUtils.test)('should ask about missing module and cancel install', ['schema1'], [REMOTE_MODULE], false), _dec6 = (0, _testUtils.test)('should ask about missing module and do install', ['schema1'], [REMOTE_MODULE], true), _dec7 = (0, _testUtils.test)('should ask about missing module and do install', ['schema1', 'schema2'], [REMOTE_MODULE, REMOTE_MODULE2], true), _dec8 = (0, _testUtils.test)('does not return the same module twice', ['schema1', 'schema1b', 'schema2'], [REMOTE_MODULE, REMOTE_MODULE2], true), _dec9 = (0, _testUtils.test)('schemas are imported from one module', ['schema1']), _dec10 = (0, _testUtils.test)('schemas are imported from two modules', ['schema1', 'schema2']), _dec11 = (0, _testUtils.test)('can reference impored from another module', ["import * as HeartwoodTypesLocal from '@sprucelabs/heartwood-view-controllers'"]), _dec12 = (0, _testUtils.test)('can reference impored from another module with two importsWhenLocal', ["import * as HeartwoodTypesLocal from '@sprucelabs/heartwood-view-controllers'", "import * as HeartwoodTypesLocal2 from '@sprucelabs/heartwood-view-controllers'"]), _dec13 = (0, _testUtils.test)(), _dec14 = (0, _testUtils.test)(), _dec15 = (0, _testUtils.test)(), (_class = (_SettingUpSchemasForModuleDistributionTest = /*#__PURE__*/function (_AbstractSkillTest) {
-  function SettingUpSchemasForModuleDistributionTest() {
-    (0, _classCallCheck2["default"])(this, SettingUpSchemasForModuleDistributionTest);
-    return _callSuper(this, SettingUpSchemasForModuleDistributionTest, arguments);
-  }
-  (0, _inherits2["default"])(SettingUpSchemasForModuleDistributionTest, _AbstractSkillTest);
-  return (0, _createClass2["default"])(SettingUpSchemasForModuleDistributionTest, null, [{
-    key: "canSpecifyModuleToImportFromWhenRemote",
-    value: function () {
-      var _canSpecifyModuleToImportFromWhenRemote = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(namePascal, remoteModule, count) {
-        var nameCamel, promise, results, builderFile, builder, schemaFile, schema;
-        return _regenerator["default"].wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              nameCamel = _spruceSkillUtils.namesUtil.toCamel(namePascal);
-              promise = this.Action('schema', 'create').execute({
-                nameReadable: 'Schema imported as module',
-                namePascal: namePascal,
-                nameCamel: nameCamel,
-                moduleToImportFromWhenRemote: remoteModule
-              });
-              _context.next = 4;
-              return this.wait(10);
-            case 4:
-              if (!this.ui.isWaitingForInput()) {
-                _context.next = 7;
-                break;
-              }
-              _context.next = 7;
-              return this.ui.sendInput(_spruceSkillUtils.versionUtil.generateVersion().constValue);
-            case 7:
-              _context.next = 9;
-              return promise;
-            case 9:
-              results = _context.sent;
-              _testUtils.assert.isFalsy(results.errors);
-              builderFile = _test["default"].assertFileByNameInGeneratedFiles("".concat(nameCamel, ".builder.ts"), results.files);
-              _context.next = 14;
-              return this.Service('import').importDefault(builderFile);
-            case 14:
-              builder = _context.sent;
-              _testUtils.assert.isEqual(builder.moduleToImportFromWhenRemote, remoteModule);
-
-              //@ts-ignore
-              this["builder".concat(count)] = builder;
-              schemaFile = _test["default"].assertFileByNameInGeneratedFiles("".concat(nameCamel, ".schema.ts"), results.files);
-              _context.next = 20;
-              return this.Service('import').importDefault(schemaFile);
-            case 20:
-              schema = _context.sent;
-              _testUtils.assert.isEqual(schema.moduleToImportFromWhenRemote, remoteModule);
-
-              //@ts-ignore
-              this["schema".concat(count)] = schema;
-              //@ts-ignore
-              this["schema".concat(count, "b")] = _objectSpread(_objectSpread({}, schema), {}, {
-                id: "schema".concat(count, "B")
-              });
-            case 24:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function canSpecifyModuleToImportFromWhenRemote(_x, _x2, _x3) {
-        return _canSpecifyModuleToImportFromWhenRemote.apply(this, arguments);
-      }
-      return canSpecifyModuleToImportFromWhenRemote;
-    }()
-  }, {
-    key: "templateItemGeneratorHonorsModuleToImportWhenRemoteWhenInRemoteNamespace",
-    value: function () {
-      var _templateItemGeneratorHonorsModuleToImportWhenRemoteWhenInRemoteNamespace = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
-        var templateItems, _iterator, _step, templateItem;
-        return _regenerator["default"].wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              templateItems = this.generateTemplateItems(REMOTE_NAMESPACE);
-              _iterator = _createForOfIteratorHelper(templateItems);
-              try {
-                for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                  templateItem = _step.value;
-                  _testUtils.assert.isEqual(templateItem.schema.moduleToImportFromWhenRemote, REMOTE_MODULE);
-                  _testUtils.assert.isEqual(templateItem.importFrom, REMOTE_MODULE);
-                }
-              } catch (err) {
-                _iterator.e(err);
-              } finally {
-                _iterator.f();
-              }
-            case 3:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this);
-      }));
-      function templateItemGeneratorHonorsModuleToImportWhenRemoteWhenInRemoteNamespace() {
-        return _templateItemGeneratorHonorsModuleToImportWhenRemoteWhenInRemoteNamespace.apply(this, arguments);
-      }
-      return templateItemGeneratorHonorsModuleToImportWhenRemoteWhenInRemoteNamespace;
-    }()
-  }, {
-    key: "moduleToImportWhenRemoteIgnoredWhenInSameNamespace",
-    value: function () {
-      var _moduleToImportWhenRemoteIgnoredWhenInSameNamespace = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
-        var templateItems, _iterator2, _step2, templateItem;
-        return _regenerator["default"].wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              templateItems = this.generateTemplateItems(LOCAL_NAMESPACE);
-              _iterator2 = _createForOfIteratorHelper(templateItems);
-              try {
-                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                  templateItem = _step2.value;
-                  _testUtils.assert.isEqual(templateItem.schema.moduleToImportFromWhenRemote, REMOTE_MODULE);
-                  _testUtils.assert.isFalse('importFrom' in templateItem);
-                }
-              } catch (err) {
-                _iterator2.e(err);
-              } finally {
-                _iterator2.f();
-              }
-            case 3:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this);
-      }));
-      function moduleToImportWhenRemoteIgnoredWhenInSameNamespace() {
-        return _moduleToImportWhenRemoteIgnoredWhenInSameNamespace.apply(this, arguments);
-      }
-      return moduleToImportWhenRemoteIgnoredWhenInSameNamespace;
-    }()
-  }, {
-    key: "asksIfModuleShouldBeInstalled",
-    value: function () {
-      var _asksIfModuleShouldBeInstalled = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(schemaNames, expectedModules, shouldConfirmInstall) {
-        var _this = this;
-        var schemas, promise, secondToLast, _iterator3, _step3, _expected, results, pkg, _iterator4, _step4, expected;
-        return _regenerator["default"].wrap(function _callee5$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
-            case 0:
-              _context5.next = 2;
-              return this.reInstallSkill();
-            case 2:
-              _context5.next = 4;
-              return this.Store('skill').setCurrentSkillsNamespace('TestingTwo');
-            case 4:
-              schemas = schemaNames.map(function (name) {
-                return _this[name];
-              });
-              _context5.next = 7;
-              return this.emitter.on('schema.did-fetch-schemas', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
-                return _regenerator["default"].wrap(function _callee4$(_context4) {
-                  while (1) switch (_context4.prev = _context4.next) {
-                    case 0:
-                      return _context4.abrupt("return", {
-                        schemas: schemas
-                      });
-                    case 1:
-                    case "end":
-                      return _context4.stop();
-                  }
-                }, _callee4);
-              })));
-            case 7:
-              promise = this.SyncAction().execute({});
-              _context5.next = 10;
-              return this.waitForInput();
-            case 10:
-              secondToLast = this.ui.invocations[this.ui.invocations.length - 2];
-              _testUtils.assert.isEqual(secondToLast.options.headline, "Missing ".concat(expectedModules.length, " module").concat(expectedModules.length === 1 ? '' : 's'));
-              _iterator3 = _createForOfIteratorHelper(expectedModules);
-              try {
-                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-                  _expected = _step3.value;
-                  _testUtils.assert.doesInclude(secondToLast.options.lines, _expected);
-                }
-              } catch (err) {
-                _iterator3.e(err);
-              } finally {
-                _iterator3.f();
-              }
-              _context5.next = 16;
-              return this.ui.sendInput(shouldConfirmInstall ? 'y' : 'n');
-            case 16:
-              _context5.next = 18;
-              return promise;
-            case 18:
-              results = _context5.sent;
-              if (shouldConfirmInstall) {
-                _testUtils.assert.isFalsy(results.errors);
-                pkg = this.Service('pkg');
-                _iterator4 = _createForOfIteratorHelper(expectedModules);
-                try {
-                  for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-                    expected = _step4.value;
-                    _testUtils.assert.isTrue(pkg.isInstalled(expected));
-                  }
-                } catch (err) {
-                  _iterator4.e(err);
-                } finally {
-                  _iterator4.f();
-                }
-              } else {
-                _testUtils.assert.isTruthy(results.errors);
-                _testUtils.errorAssert.assertError(results.errors[0], 'ACTION_CANCELLED');
-              }
-            case 20:
-            case "end":
-              return _context5.stop();
-          }
-        }, _callee5, this);
-      }));
-      function asksIfModuleShouldBeInstalled(_x4, _x5, _x6) {
-        return _asksIfModuleShouldBeInstalled.apply(this, arguments);
-      }
-      return asksIfModuleShouldBeInstalled;
-    }()
-  }, {
-    key: "schemasAreImportedFromModuleWhenSyncedFromDifferentNamespace",
-    value: function () {
-      var _schemasAreImportedFromModuleWhenSyncedFromDifferentNamespace = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7(schemaNames) {
-        var schemas, _iterator5, _step5, name, results;
-        return _regenerator["default"].wrap(function _callee7$(_context7) {
-          while (1) switch (_context7.prev = _context7.next) {
-            case 0:
-              _context7.next = 2;
-              return this.reInstallSkill();
-            case 2:
-              _context7.next = 4;
-              return this.Store('skill').setCurrentSkillsNamespace('TestingTwo');
-            case 4:
-              schemas = [];
-              _iterator5 = _createForOfIteratorHelper(schemaNames);
-              try {
-                for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-                  name = _step5.value;
-                  schemas.push(this[name]);
-                }
-              } catch (err) {
-                _iterator5.e(err);
-              } finally {
-                _iterator5.f();
-              }
-              _context7.next = 9;
-              return this.emitter.on('schema.did-fetch-schemas', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6() {
-                return _regenerator["default"].wrap(function _callee6$(_context6) {
-                  while (1) switch (_context6.prev = _context6.next) {
-                    case 0:
-                      return _context6.abrupt("return", {
-                        schemas: schemas
-                      });
-                    case 1:
-                    case "end":
-                      return _context6.stop();
-                  }
-                }, _callee6);
-              })));
-            case 9:
-              _context7.next = 11;
-              return this.SyncAction().execute({
-                shouldInstallMissingDependencies: true
-              });
-            case 11:
-              results = _context7.sent;
-              _context7.next = 14;
-              return this.assertCalendarEventSchemaIsImported(results);
-            case 14:
-              _testUtils.assert.doesThrow(function () {
-                return _test["default"].assertFileByNameInGeneratedFiles('schemas.types.ts', results.files);
-              });
-            case 15:
-            case "end":
-              return _context7.stop();
-          }
-        }, _callee7, this);
-      }));
-      function schemasAreImportedFromModuleWhenSyncedFromDifferentNamespace(_x7) {
-        return _schemasAreImportedFromModuleWhenSyncedFromDifferentNamespace.apply(this, arguments);
-      }
-      return schemasAreImportedFromModuleWhenSyncedFromDifferentNamespace;
-    }()
-  }, {
-    key: "canReferenceSchemaImportedFromAnotherModule",
-    value: function () {
-      var _canReferenceSchemaImportedFromAnotherModule = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9(importsWhenRemote) {
-        var mySchema, results, localSchemaFile, localSchema;
-        return _regenerator["default"].wrap(function _callee9$(_context9) {
-          while (1) switch (_context9.prev = _context9.next) {
-            case 0:
-              _context9.next = 2;
-              return this.reInstallSkill();
-            case 2:
-              _context9.next = 4;
-              return this.Store('skill').setCurrentSkillsNamespace('TestingTwo');
-            case 4:
-              mySchema = {
-                id: 'localSchema',
-                importsWhenRemote: importsWhenRemote,
-                fields: {
-                  calendarEvent: {
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
+const test_utils_1 = require("@sprucelabs/test-utils");
+const test_utils_2 = require("@sprucelabs/test-utils");
+const SchemaTemplateItemBuilder_1 = __importDefault(require("../../../templateItemBuilders/SchemaTemplateItemBuilder"));
+const AbstractSkillTest_1 = __importDefault(require("../../../tests/AbstractSkillTest"));
+const test_utility_1 = __importDefault(require("../../../tests/utilities/test.utility"));
+const LOCAL_NAMESPACE = 'TestingSchemas';
+const REMOTE_NAMESPACE = 'RemoteSchemas';
+const REMOTE_MODULE = '@sprucelabs/calendar-utils';
+const REMOTE_MODULE2 = '@sprucelabs/spruce-templates';
+class SettingUpSchemasForModuleDistributionTest extends AbstractSkillTest_1.default {
+    static skillCacheKey = 'schemas';
+    static builder1;
+    static schema1 = {
+        id: 'calendarEvent',
+        version: 'v2021_09_20',
+        namespace: 'TestingSchemas',
+        name: 'Schema imported as module',
+        moduleToImportFromWhenRemote: '@sprucelabs/calendar-utils',
+        fields: {
+            fieldName1: {
+                label: 'First Field',
+                type: 'text',
+                isRequired: true,
+            },
+            fieldName2: {
+                label: 'Second Field',
+                type: 'number',
+                isRequired: true,
+                hint: 'A hint',
+            },
+        },
+    };
+    //@ts-ignore
+    static schema1b;
+    static schema2 = {
+        id: 'calendarEvent2',
+        version: 'v2021_09_20',
+        namespace: 'TestingSchemas',
+        name: 'Schema imported as module',
+        moduleToImportFromWhenRemote: '@sprucelabs/spruce-templates',
+        fields: {
+            fieldName1: {
+                label: 'First Field',
+                type: 'text',
+                isRequired: true,
+            },
+            fieldName2: {
+                label: 'Second Field',
+                type: 'number',
+                isRequired: true,
+                hint: 'A hint',
+            },
+        },
+    };
+    static async canSpecifyModuleToImportFromWhenRemote(namePascal, remoteModule, count) {
+        const nameCamel = spruce_skill_utils_1.namesUtil.toCamel(namePascal);
+        const promise = this.Action('schema', 'create').execute({
+            nameReadable: 'Schema imported as module',
+            namePascal,
+            nameCamel,
+            moduleToImportFromWhenRemote: remoteModule,
+        });
+        await this.wait(10);
+        if (this.ui.isWaitingForInput()) {
+            await this.ui.sendInput(spruce_skill_utils_1.versionUtil.generateVersion().constValue);
+        }
+        const results = await promise;
+        test_utils_1.assert.isFalsy(results.errors);
+        const builderFile = test_utility_1.default.assertFileByNameInGeneratedFiles(`${nameCamel}.builder.ts`, results.files);
+        const builder = await this.Service('import').importDefault(builderFile);
+        test_utils_1.assert.isEqual(builder.moduleToImportFromWhenRemote, remoteModule);
+        //@ts-ignore
+        this[`builder${count}`] = builder;
+        const schemaFile = test_utility_1.default.assertFileByNameInGeneratedFiles(`${nameCamel}.schema.ts`, results.files);
+        const schema = await this.Service('import').importDefault(schemaFile);
+        test_utils_1.assert.isEqual(schema.moduleToImportFromWhenRemote, remoteModule);
+        //@ts-ignore
+        this[`schema${count}`] = schema;
+        //@ts-ignore
+        this[`schema${count}b`] = { ...schema, id: `schema${count}B` };
+    }
+    static async templateItemGeneratorHonorsModuleToImportWhenRemoteWhenInRemoteNamespace() {
+        const templateItems = this.generateTemplateItems(REMOTE_NAMESPACE);
+        for (const templateItem of templateItems) {
+            test_utils_1.assert.isEqual(templateItem.schema.moduleToImportFromWhenRemote, REMOTE_MODULE);
+            test_utils_1.assert.isEqual(templateItem.importFrom, REMOTE_MODULE);
+        }
+    }
+    static async moduleToImportWhenRemoteIgnoredWhenInSameNamespace() {
+        const templateItems = this.generateTemplateItems(LOCAL_NAMESPACE);
+        for (const templateItem of templateItems) {
+            test_utils_1.assert.isEqual(templateItem.schema.moduleToImportFromWhenRemote, REMOTE_MODULE);
+            test_utils_1.assert.isFalse('importFrom' in templateItem);
+        }
+    }
+    static async asksIfModuleShouldBeInstalled(schemaNames, expectedModules, shouldConfirmInstall) {
+        await this.reInstallSkill();
+        await this.Store('skill').setCurrentSkillsNamespace('TestingTwo');
+        const schemas = schemaNames.map((name) => this[name]);
+        await this.emitter.on('schema.did-fetch-schemas', async () => {
+            return {
+                schemas,
+            };
+        });
+        const promise = this.SyncAction().execute({});
+        await this.waitForInput();
+        const secondToLast = this.ui.invocations[this.ui.invocations.length - 2];
+        test_utils_1.assert.isEqual(secondToLast.options.headline, `Missing ${expectedModules.length} module${expectedModules.length === 1 ? '' : 's'}`);
+        for (const expected of expectedModules) {
+            test_utils_1.assert.doesInclude(secondToLast.options.lines, expected);
+        }
+        await this.ui.sendInput(shouldConfirmInstall ? 'y' : 'n');
+        const results = await promise;
+        if (shouldConfirmInstall) {
+            test_utils_1.assert.isFalsy(results.errors);
+            const pkg = this.Service('pkg');
+            for (const expected of expectedModules) {
+                test_utils_1.assert.isTrue(pkg.isInstalled(expected));
+            }
+        }
+        else {
+            test_utils_1.assert.isTruthy(results.errors);
+            test_utils_2.errorAssert.assertError(results.errors[0], 'ACTION_CANCELLED');
+        }
+    }
+    static async schemasAreImportedFromModuleWhenSyncedFromDifferentNamespace(schemaNames) {
+        await this.reInstallSkill();
+        await this.Store('skill').setCurrentSkillsNamespace('TestingTwo');
+        const schemas = [];
+        for (const name of schemaNames) {
+            schemas.push(this[name]);
+        }
+        await this.emitter.on('schema.did-fetch-schemas', async () => {
+            return {
+                schemas,
+            };
+        });
+        const results = await this.SyncAction().execute({
+            shouldInstallMissingDependencies: true,
+        });
+        await this.assertCalendarEventSchemaIsImported(results);
+        test_utils_1.assert.doesThrow(() => test_utility_1.default.assertFileByNameInGeneratedFiles('schemas.types.ts', results.files));
+    }
+    static async canReferenceSchemaImportedFromAnotherModule(importsWhenRemote) {
+        await this.reInstallSkill();
+        await this.Store('skill').setCurrentSkillsNamespace('TestingTwo');
+        const mySchema = {
+            id: 'localSchema',
+            importsWhenRemote,
+            fields: {
+                calendarEvent: {
                     type: 'schema',
                     options: {
-                      schema: _objectSpread(_objectSpread({}, this.schema1), {}, {
-                        namespace: 'CalendarUtils',
-                        version: 'v2021_05_19'
-                      })
-                    }
-                  }
-                }
-              };
-              _context9.next = 7;
-              return this.emitter.on('schema.did-fetch-schemas', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8() {
-                return _regenerator["default"].wrap(function _callee8$(_context8) {
-                  while (1) switch (_context8.prev = _context8.next) {
-                    case 0:
-                      return _context8.abrupt("return", {
-                        schemas: [mySchema]
-                      });
-                    case 1:
-                    case "end":
-                      return _context8.stop();
-                  }
-                }, _callee8);
-              })));
-            case 7:
-              _context9.next = 9;
-              return this.SyncAction().execute({
-                shouldInstallMissingDependencies: true
-              });
-            case 9:
-              results = _context9.sent;
-              localSchemaFile = _test["default"].assertFileByNameInGeneratedFiles('localSchema.schema.ts', results.files);
-              _context9.next = 13;
-              return this.Service('import').importDefault(localSchemaFile);
-            case 13:
-              localSchema = _context9.sent;
-              _testUtils.assert.isEqualDeep(localSchema.importsWhenRemote, importsWhenRemote);
-              _context9.next = 17;
-              return this.assertCalendarEventSchemaIsImported(results);
-            case 17:
-              _context9.next = 19;
-              return this.assertValidTypesFileWhenAddingRemoteImport(results);
-            case 19:
-            case "end":
-              return _context9.stop();
-          }
-        }, _callee9, this);
-      }));
-      function canReferenceSchemaImportedFromAnotherModule(_x8) {
-        return _canReferenceSchemaImportedFromAnotherModule.apply(this, arguments);
-      }
-      return canReferenceSchemaImportedFromAnotherModule;
-    }()
-  }, {
-    key: "canSetImportFromModuleWithNestedSchemasWhenRemoteWhenSyncing",
-    value: function () {
-      var _canSetImportFromModuleWithNestedSchemasWhenRemoteWhenSyncing = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10() {
-        var results;
-        return _regenerator["default"].wrap(function _callee10$(_context10) {
-          while (1) switch (_context10.prev = _context10.next) {
-            case 0:
-              _context10.next = 2;
-              return this.reInstallSkill();
-            case 2:
-              _context10.next = 4;
-              return this.Action('schema', 'create').execute({
-                nameReadable: 'Schema imported as module',
-                namePascal: 'CalandarEvent',
-                nameCamel: 'calendarEvent'
-              });
-            case 4:
-              _context10.next = 6;
-              return this.SyncAction().execute({
-                moduleToImportFromWhenRemote: REMOTE_MODULE
-              });
-            case 6:
-              results = _context10.sent;
-              _context10.next = 9;
-              return this.importGeneratedFile(results, "calendarEvent.schema.ts");
-            case 9:
-              this.schema1 = _context10.sent;
-              _testUtils.assert.isEqual(this.schema1.moduleToImportFromWhenRemote, REMOTE_MODULE);
-            case 11:
-            case "end":
-              return _context10.stop();
-          }
-        }, _callee10, this);
-      }));
-      function canSetImportFromModuleWithNestedSchemasWhenRemoteWhenSyncing() {
-        return _canSetImportFromModuleWithNestedSchemasWhenRemoteWhenSyncing.apply(this, arguments);
-      }
-      return canSetImportFromModuleWithNestedSchemasWhenRemoteWhenSyncing;
-    }()
-  }, {
-    key: "canHandleFormBuilderImportExportObject",
-    value: function () {
-      var _canHandleFormBuilderImportExportObject = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee11() {
-        var _results$find;
-        var version, completedFormBuilder, builderForm, itemBuilder, results;
-        return _regenerator["default"].wrap(function _callee11$(_context11) {
-          while (1) switch (_context11.prev = _context11.next) {
-            case 0:
-              version = _spruceSkillUtils.versionUtil.generateVersion().constValue;
-              completedFormBuilder = {
-                id: 'fullCompletedForm',
-                version: version,
-                moduleToImportFromWhenRemote: '@sprucelabs/heartwood-view-controllers',
-                fields: {
-                  id: {
+                        schema: {
+                            ...this.schema1,
+                            namespace: 'CalendarUtils',
+                            version: 'v2021_05_19',
+                        },
+                    },
+                },
+            },
+        };
+        await this.emitter.on('schema.did-fetch-schemas', async () => {
+            return {
+                schemas: [mySchema],
+            };
+        });
+        const results = await this.SyncAction().execute({
+            shouldInstallMissingDependencies: true,
+        });
+        const localSchemaFile = test_utility_1.default.assertFileByNameInGeneratedFiles('localSchema.schema.ts', results.files);
+        const localSchema = await this.Service('import').importDefault(localSchemaFile);
+        test_utils_1.assert.isEqualDeep(localSchema.importsWhenRemote, importsWhenRemote);
+        await this.assertCalendarEventSchemaIsImported(results);
+        await this.assertValidTypesFileWhenAddingRemoteImport(results);
+    }
+    static async canSetImportFromModuleWithNestedSchemasWhenRemoteWhenSyncing() {
+        await this.reInstallSkill();
+        await this.Action('schema', 'create').execute({
+            nameReadable: 'Schema imported as module',
+            namePascal: 'CalandarEvent',
+            nameCamel: 'calendarEvent',
+        });
+        const results = await this.SyncAction().execute({
+            moduleToImportFromWhenRemote: REMOTE_MODULE,
+        });
+        this.schema1 = (await this.importGeneratedFile(results, `calendarEvent.schema.ts`));
+        test_utils_1.assert.isEqual(this.schema1.moduleToImportFromWhenRemote, REMOTE_MODULE);
+    }
+    static async canHandleFormBuilderImportExportObject() {
+        const version = spruce_skill_utils_1.versionUtil.generateVersion().constValue;
+        const completedFormBuilder = {
+            id: 'fullCompletedForm',
+            version,
+            moduleToImportFromWhenRemote: '@sprucelabs/heartwood-view-controllers',
+            fields: {
+                id: {
                     type: 'id',
-                    isRequired: true
-                  },
-                  personId: {
+                    isRequired: true,
+                },
+                personId: {
                     type: 'id',
-                    isRequired: true
-                  },
-                  values: {
+                    isRequired: true,
+                },
+                values: {
                     type: 'raw',
                     isArray: true,
                     options: {
-                      valueType: 'Record<string, any>'
-                    }
-                  }
-                }
-              };
-              builderForm = {
-                id: 'builtForm',
-                version: version,
-                moduleToImportFromWhenRemote: '@sprucelabs/heartwood-view-controllers',
-                fields: {
-                  id: {
+                        valueType: 'Record<string, any>',
+                    },
+                },
+            },
+        };
+        const builderForm = {
+            id: 'builtForm',
+            version,
+            moduleToImportFromWhenRemote: '@sprucelabs/heartwood-view-controllers',
+            fields: {
+                id: {
                     type: 'id',
-                    isRequired: true
-                  },
-                  dateDeleted: {
-                    type: 'number'
-                  },
-                  completedFormBuilder: {
+                    isRequired: true,
+                },
+                dateDeleted: {
+                    type: 'number',
+                },
+                completedFormBuilder: {
                     type: 'schema',
                     options: {
-                      schemaId: {
-                        version: version,
-                        id: 'fullCompletedForm'
-                      }
-                    }
-                  }
-                }
-              };
-              itemBuilder = new _SchemaTemplateItemBuilder["default"]('TestSkill');
-              results = itemBuilder.buildTemplateItems({
-                //@ts-ignore
-                TestSkill: [completedFormBuilder, builderForm]
-              });
-              _testUtils.assert.isFalsy((_results$find = results.find(function (r) {
-                return r.id === 'builtForm';
-              })) === null || _results$find === void 0 || (_results$find = _results$find.schema.fields) === null || _results$find === void 0 || (_results$find = _results$find.completedFormBuilder) === null || _results$find === void 0 || (_results$find = _results$find.options) === null || _results$find === void 0 || (_results$find = _results$find.schemaIds) === null || _results$find === void 0 || (_results$find = _results$find[0]) === null || _results$find === void 0 ? void 0 : _results$find.moduleToImportFromWhenRemote);
-            case 6:
-            case "end":
-              return _context11.stop();
-          }
-        }, _callee11);
-      }));
-      function canHandleFormBuilderImportExportObject() {
-        return _canHandleFormBuilderImportExportObject.apply(this, arguments);
-      }
-      return canHandleFormBuilderImportExportObject;
-    }()
-  }, {
-    key: "importedSchemasDoNotShowUpInSchemaTypes",
-    value: function () {
-      var _importedSchemasDoNotShowUpInSchemaTypes = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee13() {
-        var schema1, schema2, results, schemaTypesFile;
-        return _regenerator["default"].wrap(function _callee13$(_context13) {
-          while (1) switch (_context13.prev = _context13.next) {
-            case 0:
-              _context13.next = 2;
-              return this.Store('skill').setCurrentSkillsNamespace('TestingTwo');
-            case 2:
-              schema1 = {
-                id: 'fullCompletedForm',
-                namespace: 'Heartwood',
-                version: _spruceSkillUtils.versionUtil.generateVersion().dirValue,
-                moduleToImportFromWhenRemote: '@sprucelabs/heartwood-view-controllers',
-                importsWhenRemote: ['import * from bananarama'],
-                fields: {
-                  id: {
+                        schemaId: {
+                            version,
+                            id: 'fullCompletedForm',
+                        },
+                    },
+                },
+            },
+        };
+        const itemBuilder = new SchemaTemplateItemBuilder_1.default('TestSkill');
+        const results = itemBuilder.buildTemplateItems({
+            //@ts-ignore
+            TestSkill: [completedFormBuilder, builderForm],
+        });
+        test_utils_1.assert.isFalsy(results.find((r) => r.id === 'builtForm')?.schema.fields
+            ?.completedFormBuilder?.options?.schemaIds?.[0]?.moduleToImportFromWhenRemote);
+    }
+    static async importedSchemasDoNotShowUpInSchemaTypes() {
+        // await this.reInstallSkill()
+        await this.Store('skill').setCurrentSkillsNamespace('TestingTwo');
+        const schema1 = {
+            id: 'fullCompletedForm',
+            namespace: 'Heartwood',
+            version: spruce_skill_utils_1.versionUtil.generateVersion().dirValue,
+            moduleToImportFromWhenRemote: '@sprucelabs/heartwood-view-controllers',
+            importsWhenRemote: ['import * from bananarama'],
+            fields: {
+                id: {
                     type: 'id',
-                    isRequired: true
-                  },
-                  personId: {
+                    isRequired: true,
+                },
+                personId: {
                     type: 'id',
-                    isRequired: true
-                  },
-                  values: {
+                    isRequired: true,
+                },
+                values: {
                     type: 'raw',
                     isArray: true,
                     options: {
-                      valueType: 'Record<string, any>'
-                    }
-                  }
-                }
-              };
-              schema2 = {
-                id: 'localCompleted',
-                version: _spruceSkillUtils.versionUtil.generateVersion().dirValue,
-                fields: {
-                  id: {
+                        valueType: 'Record<string, any>',
+                    },
+                },
+            },
+        };
+        const schema2 = {
+            id: 'localCompleted',
+            version: spruce_skill_utils_1.versionUtil.generateVersion().dirValue,
+            fields: {
+                id: {
                     type: 'id',
-                    isRequired: true
-                  },
-                  personId: {
+                    isRequired: true,
+                },
+                personId: {
                     type: 'id',
-                    isRequired: true
-                  },
-                  values: {
+                    isRequired: true,
+                },
+                values: {
                     type: 'raw',
                     isArray: true,
                     options: {
-                      valueType: 'Record<string, any>'
-                    }
-                  }
-                }
-              };
-              _context13.next = 6;
-              return this.emitter.on('schema.did-fetch-schemas', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee12() {
-                return _regenerator["default"].wrap(function _callee12$(_context12) {
-                  while (1) switch (_context12.prev = _context12.next) {
-                    case 0:
-                      return _context12.abrupt("return", {
-                        schemas: [schema1, schema2]
-                      });
-                    case 1:
-                    case "end":
-                      return _context12.stop();
-                  }
-                }, _callee12);
-              })));
-            case 6:
-              _context13.next = 8;
-              return this.SyncAction().execute({
-                shouldInstallMissingDependencies: true
-              });
-            case 8:
-              results = _context13.sent;
-              _testUtils.assert.isFalsy(results.errors);
-              schemaTypesFile = _test["default"].assertFileByNameInGeneratedFiles('schemas.types.ts', results.files);
-              _context13.next = 13;
-              return this.Service('typeChecker').check(schemaTypesFile);
-            case 13:
-            case "end":
-              return _context13.stop();
-          }
-        }, _callee13, this);
-      }));
-      function importedSchemasDoNotShowUpInSchemaTypes() {
-        return _importedSchemasDoNotShowUpInSchemaTypes.apply(this, arguments);
-      }
-      return importedSchemasDoNotShowUpInSchemaTypes;
-    }()
-  }, {
-    key: "SyncAction",
-    value: function SyncAction() {
-      return this.Action('schema', 'sync', {
-        optionOverrides: {
-          'sync.schemas': {}
-        }
-      });
+                        valueType: 'Record<string, any>',
+                    },
+                },
+            },
+        };
+        await this.emitter.on('schema.did-fetch-schemas', async () => {
+            return {
+                schemas: [schema1, schema2],
+            };
+        });
+        const results = await this.SyncAction().execute({
+            shouldInstallMissingDependencies: true,
+        });
+        test_utils_1.assert.isFalsy(results.errors);
+        const schemaTypesFile = test_utility_1.default.assertFileByNameInGeneratedFiles('schemas.types.ts', results.files);
+        await this.Service('typeChecker').check(schemaTypesFile);
     }
-  }, {
-    key: "importGeneratedFile",
-    value: function () {
-      var _importGeneratedFile = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee14(results, fileName) {
-        var schemaFile;
-        return _regenerator["default"].wrap(function _callee14$(_context14) {
-          while (1) switch (_context14.prev = _context14.next) {
-            case 0:
-              schemaFile = _test["default"].assertFileByNameInGeneratedFiles(fileName, results.files);
-              _context14.next = 3;
-              return this.Service('import').importDefault(schemaFile);
-            case 3:
-              return _context14.abrupt("return", _context14.sent);
-            case 4:
-            case "end":
-              return _context14.stop();
-          }
-        }, _callee14, this);
-      }));
-      function importGeneratedFile(_x9, _x10) {
-        return _importGeneratedFile.apply(this, arguments);
-      }
-      return importGeneratedFile;
-    }()
-  }, {
-    key: "assertCalendarEventSchemaIsImported",
-    value: function () {
-      var _assertCalendarEventSchemaIsImported = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee15(results) {
-        var imported, calendarEventContents;
-        return _regenerator["default"].wrap(function _callee15$(_context15) {
-          while (1) switch (_context15.prev = _context15.next) {
-            case 0:
-              _testUtils.assert.isFalsy(results.errors);
-              imported = _test["default"].assertFileByNameInGeneratedFiles('calendarEvent.schema.ts', results.files);
-              calendarEventContents = _spruceSkillUtils.diskUtil.readFile(imported);
-              _testUtils.assert.isEqual(calendarEventContents.trim(), "export { calendarEventSchema as default } from '@sprucelabs/calendar-utils'");
-            case 4:
-            case "end":
-              return _context15.stop();
-          }
-        }, _callee15);
-      }));
-      function assertCalendarEventSchemaIsImported(_x11) {
-        return _assertCalendarEventSchemaIsImported.apply(this, arguments);
-      }
-      return assertCalendarEventSchemaIsImported;
-    }()
-  }, {
-    key: "generateTemplateItems",
-    value: function generateTemplateItems(namespace) {
-      var itemBuilder = new _SchemaTemplateItemBuilder["default"](namespace);
-      var templateItems = itemBuilder.buildTemplateItems((0, _defineProperty2["default"])({}, LOCAL_NAMESPACE, [_objectSpread(_objectSpread({}, this.builder1), {}, {
-        fields: _objectSpread(_objectSpread({}, this.builder1.fields), {}, {
-          nestedSchema: {
-            type: 'schema',
-            options: {
-              schema: {
-                id: 'nested',
-                fields: {
-                  firstName: {
-                    type: 'text'
-                  }
-                }
-              }
-            }
-          }
-        })
-      })]), this.resolveHashSprucePath('schemas'));
-      return templateItems;
+    static SyncAction() {
+        return this.Action('schema', 'sync', {
+            optionOverrides: {
+                'sync.schemas': {},
+            },
+        });
+    }
+    static async importGeneratedFile(results, fileName) {
+        const schemaFile = test_utility_1.default.assertFileByNameInGeneratedFiles(fileName, results.files);
+        return await this.Service('import').importDefault(schemaFile);
+    }
+    static async assertCalendarEventSchemaIsImported(results) {
+        test_utils_1.assert.isFalsy(results.errors);
+        const imported = test_utility_1.default.assertFileByNameInGeneratedFiles('calendarEvent.schema.ts', results.files);
+        const calendarEventContents = spruce_skill_utils_1.diskUtil.readFile(imported);
+        test_utils_1.assert.isEqual(calendarEventContents.trim(), `export { calendarEventSchema as default } from '@sprucelabs/calendar-utils'`);
     }
-  }, {
-    key: "assertValidTypesFileWhenAddingRemoteImport",
-    value: function () {
-      var _assertValidTypesFileWhenAddingRemoteImport = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee16(results) {
-        var schemaTypesFile, typesContent;
-        return _regenerator["default"].wrap(function _callee16$(_context16) {
-          while (1) switch (_context16.prev = _context16.next) {
-            case 0:
-              schemaTypesFile = _test["default"].assertFileByNameInGeneratedFiles('schemas.types.ts', results.files);
-              typesContent = "import '".concat(REMOTE_MODULE, "'\n\n").concat(_spruceSkillUtils.diskUtil.readFile(schemaTypesFile));
-              _spruceSkillUtils.diskUtil.writeFile(schemaTypesFile, typesContent);
-              _context16.next = 5;
-              return this.Service('typeChecker').check(schemaTypesFile);
-            case 5:
-            case "end":
-              return _context16.stop();
-          }
-        }, _callee16, this);
-      }));
-      function assertValidTypesFileWhenAddingRemoteImport(_x12) {
-        return _assertValidTypesFileWhenAddingRemoteImport.apply(this, arguments);
-      }
-      return assertValidTypesFileWhenAddingRemoteImport;
-    }()
-  }]);
-}(_AbstractSkillTest2["default"]), (0, _defineProperty2["default"])(_SettingUpSchemasForModuleDistributionTest, "skillCacheKey", 'schemas'), (0, _defineProperty2["default"])(_SettingUpSchemasForModuleDistributionTest, "builder1", void 0), (0, _defineProperty2["default"])(_SettingUpSchemasForModuleDistributionTest, "schema1", {
-  id: 'calendarEvent',
-  version: 'v2021_09_20',
-  namespace: 'TestingSchemas',
-  name: 'Schema imported as module',
-  moduleToImportFromWhenRemote: '@sprucelabs/calendar-utils',
-  fields: {
-    fieldName1: {
-      label: 'First Field',
-      type: 'text',
-      isRequired: true
-    },
-    fieldName2: {
-      label: 'Second Field',
-      type: 'number',
-      isRequired: true,
-      hint: 'A hint'
+    static generateTemplateItems(namespace) {
+        const itemBuilder = new SchemaTemplateItemBuilder_1.default(namespace);
+        const templateItems = itemBuilder.buildTemplateItems({
+            [LOCAL_NAMESPACE]: [
+                {
+                    ...this.builder1,
+                    fields: {
+                        ...this.builder1.fields,
+                        nestedSchema: {
+                            type: 'schema',
+                            options: {
+                                schema: {
+                                    id: 'nested',
+                                    fields: {
+                                        firstName: {
+                                            type: 'text',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            ],
+        }, this.resolveHashSprucePath('schemas'));
+        return templateItems;
     }
-  }
-}), (0, _defineProperty2["default"])(_SettingUpSchemasForModuleDistributionTest, "schema1b", void 0), (0, _defineProperty2["default"])(_SettingUpSchemasForModuleDistributionTest, "schema2", {
-  id: 'calendarEvent2',
-  version: 'v2021_09_20',
-  namespace: 'TestingSchemas',
-  name: 'Schema imported as module',
-  moduleToImportFromWhenRemote: '@sprucelabs/spruce-templates',
-  fields: {
-    fieldName1: {
-      label: 'First Field',
-      type: 'text',
-      isRequired: true
-    },
-    fieldName2: {
-      label: 'Second Field',
-      type: 'number',
-      isRequired: true,
-      hint: 'A hint'
+    static async assertValidTypesFileWhenAddingRemoteImport(results) {
+        const schemaTypesFile = test_utility_1.default.assertFileByNameInGeneratedFiles('schemas.types.ts', results.files);
+        const typesContent = `import '${REMOTE_MODULE}'\n\n${spruce_skill_utils_1.diskUtil.readFile(schemaTypesFile)}`;
+        spruce_skill_utils_1.diskUtil.writeFile(schemaTypesFile, typesContent);
+        await this.Service('typeChecker').check(schemaTypesFile);
     }
-  }
-}), _SettingUpSchemasForModuleDistributionTest), ((0, _applyDecoratedDescriptor2["default"])(_class, "canSpecifyModuleToImportFromWhenRemote", [_dec, _dec2], Object.getOwnPropertyDescriptor(_class, "canSpecifyModuleToImportFromWhenRemote"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "templateItemGeneratorHonorsModuleToImportWhenRemoteWhenInRemoteNamespace", [_dec3], Object.getOwnPropertyDescriptor(_class, "templateItemGeneratorHonorsModuleToImportWhenRemoteWhenInRemoteNamespace"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "moduleToImportWhenRemoteIgnoredWhenInSameNamespace", [_dec4], Object.getOwnPropertyDescriptor(_class, "moduleToImportWhenRemoteIgnoredWhenInSameNamespace"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "asksIfModuleShouldBeInstalled", [_dec5, _dec6, _dec7, _dec8], Object.getOwnPropertyDescriptor(_class, "asksIfModuleShouldBeInstalled"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "schemasAreImportedFromModuleWhenSyncedFromDifferentNamespace", [_dec9, _dec10], Object.getOwnPropertyDescriptor(_class, "schemasAreImportedFromModuleWhenSyncedFromDifferentNamespace"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "canReferenceSchemaImportedFromAnotherModule", [_dec11, _dec12], Object.getOwnPropertyDescriptor(_class, "canReferenceSchemaImportedFromAnotherModule"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "canSetImportFromModuleWithNestedSchemasWhenRemoteWhenSyncing", [_dec13], Object.getOwnPropertyDescriptor(_class, "canSetImportFromModuleWithNestedSchemasWhenRemoteWhenSyncing"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "canHandleFormBuilderImportExportObject", [_dec14], Object.getOwnPropertyDescriptor(_class, "canHandleFormBuilderImportExportObject"), _class), (0, _applyDecoratedDescriptor2["default"])(_class, "importedSchemasDoNotShowUpInSchemaTypes", [_dec15], Object.getOwnPropertyDescriptor(_class, "importedSchemasDoNotShowUpInSchemaTypes"), _class)), _class));
+}
+exports.default = SettingUpSchemasForModuleDistributionTest;
+__decorate([
+    (0, test_utils_1.test)('can specify importFromModuleWhenRemote 1', 'CalendarEvent', REMOTE_MODULE, '1'),
+    (0, test_utils_1.test)('can specify importFromModuleWhenRemote 2', 'CalendarEvent2', REMOTE_MODULE2, '2')
+], SettingUpSchemasForModuleDistributionTest, "canSpecifyModuleToImportFromWhenRemote", null);
+__decorate([
+    (0, test_utils_1.test)()
+], SettingUpSchemasForModuleDistributionTest, "templateItemGeneratorHonorsModuleToImportWhenRemoteWhenInRemoteNamespace", null);
+__decorate([
+    (0, test_utils_1.test)()
+], SettingUpSchemasForModuleDistributionTest, "moduleToImportWhenRemoteIgnoredWhenInSameNamespace", null);
+__decorate([
+    (0, test_utils_1.test)('should ask about missing module and cancel install', ['schema1'], [REMOTE_MODULE], false),
+    (0, test_utils_1.test)('should ask about missing module and do install', ['schema1'], [REMOTE_MODULE], true),
+    (0, test_utils_1.test)('should ask about missing module and do install', ['schema1', 'schema2'], [REMOTE_MODULE, REMOTE_MODULE2], true),
+    (0, test_utils_1.test)('does not return the same module twice', ['schema1', 'schema1b', 'schema2'], [REMOTE_MODULE, REMOTE_MODULE2], true)
+], SettingUpSchemasForModuleDistributionTest, "asksIfModuleShouldBeInstalled", null);
+__decorate([
+    (0, test_utils_1.test)('schemas are imported from one module', ['schema1']),
+    (0, test_utils_1.test)('schemas are imported from two modules', ['schema1', 'schema2'])
+], SettingUpSchemasForModuleDistributionTest, "schemasAreImportedFromModuleWhenSyncedFromDifferentNamespace", null);
+__decorate([
+    (0, test_utils_1.test)('can reference impored from another module', [
+        `import * as HeartwoodTypesLocal from '@sprucelabs/heartwood-view-controllers'`,
+    ]),
+    (0, test_utils_1.test)('can reference impored from another module with two importsWhenLocal', [
+        `import * as HeartwoodTypesLocal from '@sprucelabs/heartwood-view-controllers'`,
+        `import * as HeartwoodTypesLocal2 from '@sprucelabs/heartwood-view-controllers'`,
+    ])
+], SettingUpSchemasForModuleDistributionTest, "canReferenceSchemaImportedFromAnotherModule", null);
+__decorate([
+    (0, test_utils_1.test)()
+], SettingUpSchemasForModuleDistributionTest, "canSetImportFromModuleWithNestedSchemasWhenRemoteWhenSyncing", null);
+__decorate([
+    (0, test_utils_1.test)()
+], SettingUpSchemasForModuleDistributionTest, "canHandleFormBuilderImportExportObject", null);
+__decorate([
+    (0, test_utils_1.test)()
+], SettingUpSchemasForModuleDistributionTest, "importedSchemasDoNotShowUpInSchemaTypes", null);
 //# sourceMappingURL=SettingUpSchemasForModuleDistribution.test.js.map