@knocklabs/cli 0.3.1 → 1.0.0

package/dist/lib/marshal/email-layout/writer.js

@@ -12,6 +12,9 @@ _export(exports, {
     get pruneLayoutsIndexDir () {
         return pruneLayoutsIndexDir;
     },
+    get writeEmailLayoutDirFromBundle () {
+        return writeEmailLayoutDirFromBundle;
+    },
     get writeEmailLayoutDirFromData () {
         return writeEmailLayoutDirFromData;
     },
@@ -82,18 +85,27 @@ const writeEmailLayoutDirFromData = async (emailLayoutDirCtx, remoteEmailLayout,
         withExtractedFiles: true
     }) : [];
     const bundle = (0, _processorisomorphic.buildEmailLayoutDirBundle)(remoteEmailLayout, localEmailLayout, withSchema ? EMAIL_LAYOUT_SCHEMA : undefined);
+    return writeEmailLayoutDirFromBundle(emailLayoutDirCtx, bundle);
+};
+/*
+ * A lower level write function that takes a constructed email layout dir bundle
+ * and writes it into a layout directory on a local file system.
+ *
+ * It does not make any assumptions about how the email layout directory bundle was
+ * built; for example, it can be from parsing the layout data fetched from
+ * the Knock API, or built manually for scaffolding purposes.
+ */ const writeEmailLayoutDirFromBundle = async (emailLayoutDirCtx, emailLayoutDirBundle)=>{
     const backupDirPath = _nodepath.default.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
     try {
-        // We store a backup in case there's an error.
         if (emailLayoutDirCtx.exists) {
             await _fsextra.copy(emailLayoutDirCtx.abspath, backupDirPath);
             await _fsextra.emptyDir(emailLayoutDirCtx.abspath);
         }
-        const promises = Object.entries(bundle).map(([relpath, fileContent])=>{
+        const promises = Object.entries(emailLayoutDirBundle).map(([relpath, fileContent])=>{
             const filePath = _nodepath.default.resolve(emailLayoutDirCtx.abspath, relpath);
             return relpath === _processorisomorphic.LAYOUT_JSON ? _fsextra.outputJson(filePath, fileContent, {
                 spaces: _json.DOUBLE_SPACES
-            }) : _fsextra.outputFile(filePath, fileContent);
+            }) : _fsextra.outputFile(filePath, fileContent !== null && fileContent !== void 0 ? fileContent : "");
         });
         await Promise.all(promises);
     } catch (error) {

package/dist/lib/marshal/guide/generator.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get generateGuideDir () {
+        return generateGuideDir;
+    },
+    get generateGuideFromTemplate () {
+        return generateGuideFromTemplate;
+    },
+    get scaffoldGuideDirBundle () {
+        return scaffoldGuideDirBundle;
+    },
+    get scaffoldValuesFromSchema () {
+        return scaffoldValuesFromSchema;
+    },
+    get validateGuideKey () {
+        return validateGuideKey;
+    }
+});
+const _string = require("../../helpers/string");
+const _templates = /*#__PURE__*/ _interop_require_wildcard(require("../../templates"));
+const _processorisomorphic = require("./processor.isomorphic");
+const _reader = require("./reader");
+const _writer = require("./writer");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const validateGuideKey = (input)=>{
+    if (!(0, _string.checkSlugifiedFormat)(input, {
+        onlyLowerCase: true
+    })) {
+        return "must include only lowercase alphanumeric, dash, or underscore characters";
+    }
+    return undefined;
+};
+const scaffoldValuesFromSchema = (fields)=>{
+    const values = {};
+    for (const field of fields){
+        switch(field.type){
+            case "text":
+            case "textarea":
+            case "markdown":
+                values[field.key] = "";
+                break;
+            case "boolean":
+                values[field.key] = false;
+                break;
+            case "select":
+            case "multi_select":
+                values[field.key] = null;
+                break;
+            case "button":
+                values[field.key] = {
+                    text: "",
+                    action: ""
+                };
+                break;
+        }
+    }
+    return values;
+};
+const scaffoldGuideDirBundle = (attrs)=>{
+    const { name, messageType, variantKey = "default" } = attrs;
+    // Find the selected variant or default to the first one
+    const variant = messageType.variants.find((v)=>v.key === variantKey) || messageType.variants[0];
+    if (!variant) {
+        throw new Error(`Message type ${messageType.key} has no variants available`);
+    }
+    // Scaffold values from the variant's field schema
+    const values = scaffoldValuesFromSchema(variant.fields);
+    const guideJson = {
+        name,
+        steps: [
+            {
+                ref: "step_1",
+                schema_key: messageType.key,
+                schema_variant_key: variant.key,
+                values
+            }
+        ]
+    };
+    return {
+        [_processorisomorphic.GUIDE_JSON]: guideJson
+    };
+};
+const generateGuideDir = async (guideDirCtx, attrs)=>{
+    const bundle = scaffoldGuideDirBundle(attrs);
+    return (0, _writer.writeGuideDirFromBundle)(guideDirCtx, bundle);
+};
+const generateGuideFromTemplate = async (guideDirCtx, templateString, attrs)=>{
+    let tempDir;
+    try {
+        // Download the template directory into a temp directory
+        tempDir = await _templates.downloadTemplate(templateString);
+        // Create a guide directory context for the temp directory
+        const tempGuideDirCtx = {
+            type: "guide",
+            key: "temp",
+            abspath: tempDir,
+            exists: true
+        };
+        // Read the guide.json from the temp directory we downloaded
+        const [guide, errors] = await (0, _reader.readGuideDir)(tempGuideDirCtx, {
+            withExtractedFiles: true
+        });
+        if (errors.length > 0 || !guide) {
+            throw new Error(`Invalid guide template: ${errors.join(", ")}`);
+        }
+        // Modify the guide data with the new attributes
+        guide.name = attrs.name;
+        // Finally, we write the guide into the target guide directory
+        (0, _writer.writeGuideDirFromData)(guideDirCtx, guide);
+        return;
+    } finally{
+        await _templates.cleanupTempDir(tempDir);
+    }
+};

package/dist/lib/marshal/guide/helpers.js

@@ -42,6 +42,7 @@ const _core = require("@oclif/core");
 const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
 const _lodash = require("lodash");
 const _quicktypecore = require("quicktype-core");
+const _projectconfig = require("../../helpers/project-config");
 const _processorisomorphic = require("./processor.isomorphic");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
@@ -107,7 +108,7 @@ const lsGuideJson = async (dirPath)=>{
     return exists ? guideJsonPath : undefined;
 };
 const isGuideDir = async (dirPath)=>Boolean(await lsGuideJson(dirPath));
-const ensureValidCommandTarget = async (props, runContext)=>{
+const ensureValidCommandTarget = async (props, runContext, projectConfig)=>{
     const { args, flags } = props;
     const { commandId, resourceDir: resourceDirCtx, cwd: runCwd } = runContext;
     // If the target resource is a different type than the current resource dir
@@ -119,6 +120,8 @@ const ensureValidCommandTarget = async (props, runContext)=>{
     if (flags.all && args.guideKey) {
         return _core.ux.error(`guideKey arg \`${args.guideKey}\` cannot also be provided when using --all`);
     }
+    // Default to knock project config first if present, otherwise cwd.
+    const guidesIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(projectConfig, "guide", runCwd);
     // --all flag is given, which means no guide key arg.
     if (flags.all) {
         // If --all flag used inside a guide directory, then require a guides
@@ -126,16 +129,9 @@ const ensureValidCommandTarget = async (props, runContext)=>{
         if (resourceDirCtx && !flags["guides-dir"]) {
             return _core.ux.error("Missing required flag guides-dir");
         }
-        // Targeting all guide dirs in the guides index dir.
-        // TODO: Default to the knock project config first if present before cwd.
-        const defaultToCwd = {
-            abspath: runCwd,
-            exists: true
-        };
-        const indexDirCtx = flags["guides-dir"] || defaultToCwd;
         return {
             type: "guidesIndexDir",
-            context: indexDirCtx
+            context: flags["guides-dir"] || guidesIndexDirCtx
         };
     }
     // Guide key arg is given, which means no --all flag.
@@ -143,7 +139,7 @@ const ensureValidCommandTarget = async (props, runContext)=>{
         if (resourceDirCtx && resourceDirCtx.key !== args.guideKey) {
             return _core.ux.error(`Cannot run ${commandId} \`${args.guideKey}\` inside another guide directory:\n${resourceDirCtx.key}`);
         }
-        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodepath.resolve(runCwd, args.guideKey);
+        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodepath.resolve(guidesIndexDirCtx.abspath, args.guideKey);
         const guideDirCtx = {
             type: "guide",
             key: args.guideKey,

package/dist/lib/marshal/guide/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./generator"), exports);
 _export_star(require("./helpers"), exports);
 _export_star(require("./processor.isomorphic"), exports);
 _export_star(require("./reader"), exports);

package/dist/lib/marshal/guide/writer.js

@@ -12,6 +12,9 @@ _export(exports, {
     get pruneGuidesIndexDir () {
         return pruneGuidesIndexDir;
     },
+    get writeGuideDirFromBundle () {
+        return writeGuideDirFromBundle;
+    },
     get writeGuideDirFromData () {
         return writeGuideDirFromData;
     },
@@ -79,14 +82,7 @@ const writeGuideDirFromData = async (guideDirCtx, remoteGuide, options)=>{
     const bundle = (0, _processorisomorphic.buildGuideDirBundle)(remoteGuide, localGuide, withSchema ? GUIDE_SCHEMA : undefined);
     return writeGuideDirFromBundle(guideDirCtx, bundle);
 };
-/*
- * A lower level write function that takes a constructed guide dir bundle
- * and writes it into a guide directory on a local file system.
- *
- * It does not make any assumptions about how the guide directory bundle was
- * built; for example, it can be from parsing the guide data fetched from
- * the Knock API, or built manually for scaffolding purposes.
- */ const writeGuideDirFromBundle = async (guideDirCtx, guideDirBundle)=>{
+const writeGuideDirFromBundle = async (guideDirCtx, guideDirBundle)=>{
     const backupDirPath = _nodepath.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
     try {
         if (guideDirCtx.exists) {
@@ -97,7 +93,7 @@ const writeGuideDirFromData = async (guideDirCtx, remoteGuide, options)=>{
             const filePath = _nodepath.resolve(guideDirCtx.abspath, relpath);
             return relpath === _processorisomorphic.GUIDE_JSON ? _fsextra.outputJson(filePath, fileContent, {
                 spaces: _json.DOUBLE_SPACES
-            }) : _fsextra.outputFile(filePath, fileContent !== null && fileContent !== void 0 ? fileContent : "");
+            }) : _fsextra.outputFile(filePath, typeof fileContent === "string" ? fileContent : "");
         });
         await Promise.all(promises);
     } catch (error) {

package/dist/lib/marshal/message-type/generator.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get generateMessageTypeDir () {
+        return generateMessageTypeDir;
+    },
+    get generateMessageTypeFromTemplate () {
+        return generateMessageTypeFromTemplate;
+    },
+    get scaffoldMessageTypeDirBundle () {
+        return scaffoldMessageTypeDirBundle;
+    },
+    get validateMessageTypeKey () {
+        return validateMessageTypeKey;
+    }
+});
+const _lodash = require("lodash");
+const _string = require("../../helpers/string");
+const _templates = /*#__PURE__*/ _interop_require_wildcard(require("../../templates"));
+const _constisomorphic = require("../shared/const.isomorphic");
+const _processorisomorphic = require("./processor.isomorphic");
+const _reader = require("./reader");
+const _writer = require("./writer");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const validateMessageTypeKey = (input)=>{
+    if (!(0, _string.checkSlugifiedFormat)(input, {
+        onlyLowerCase: true
+    })) {
+        return "must include only lowercase alphanumeric, dash, or underscore characters";
+    }
+    return undefined;
+};
+/*
+ * Returns the default scaffolded preview content.
+ */ const defaultPreviewContent = ()=>{
+    return `{{ name }}`;
+};
+/*
+ * Scaffolds a new message type directory bundle with default content.
+ */ const scaffoldMessageTypeDirBundle = (attrs)=>{
+    const previewFilePath = "preview.txt";
+    const defaultPreview = defaultPreviewContent();
+    const messageTypeJson = {
+        name: attrs.name,
+        description: "",
+        variants: [
+            {
+                key: "default",
+                name: "Default",
+                fields: []
+            }
+        ],
+        [`preview${_constisomorphic.FILEPATH_MARKER}`]: previewFilePath
+    };
+    return {
+        [_processorisomorphic.MESSAGE_TYPE_JSON]: messageTypeJson,
+        [previewFilePath]: defaultPreview
+    };
+};
+const generateMessageTypeDir = async (messageTypeDirCtx, attrs)=>{
+    const bundle = scaffoldMessageTypeDirBundle(attrs);
+    return (0, _writer.writeMessageTypeDirFromBundle)(messageTypeDirCtx, bundle);
+};
+const generateMessageTypeFromTemplate = async (messageTypeDirCtx, templateString, attrs)=>{
+    let tempDir;
+    try {
+        // Download the template directory into a temp directory
+        tempDir = await _templates.downloadTemplate(templateString);
+        // Create a message type directory context for the temp directory
+        const tempMessageTypeDirCtx = {
+            type: "message_type",
+            key: "temp",
+            abspath: tempDir,
+            exists: true
+        };
+        // Read the message_type.json from the temp directory we downloaded
+        const [messageType, errors] = await (0, _reader.readMessageTypeDir)(tempMessageTypeDirCtx, {
+            withExtractedFiles: true
+        });
+        if (errors.length > 0 || !messageType) {
+            throw new Error(`Invalid message type template: ${errors.join(", ")}`);
+        }
+        // Modify the message type data with the new attributes
+        const messageTypeData = (0, _lodash.cloneDeep)(messageType);
+        messageTypeData.name = attrs.name;
+        // Finally, we write the message type into the target message type directory
+        await (0, _writer.writeMessageTypeDirFromData)(messageTypeDirCtx, messageTypeData);
+    } finally{
+        await _templates.cleanupTempDir(tempDir);
+    }
+};

package/dist/lib/marshal/message-type/helpers.js

@@ -25,6 +25,7 @@ _export(exports, {
 const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
 const _core = require("@oclif/core");
 const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _projectconfig = require("../../helpers/project-config");
 const _processorisomorphic = require("./processor.isomorphic");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
@@ -74,7 +75,7 @@ const lsMessageTypeJson = async (dirPath)=>{
     return exists ? messageTypeJsonPath : undefined;
 };
 const isMessageTypeDir = async (dirPath)=>Boolean(await lsMessageTypeJson(dirPath));
-const ensureValidCommandTarget = async (props, runContext)=>{
+const ensureValidCommandTarget = async (props, runContext, projectConfig)=>{
     const { args, flags } = props;
     const { commandId, resourceDir: resourceDirCtx, cwd: runCwd } = runContext;
     // If the target resource is a different type than the current resource dir
@@ -86,6 +87,8 @@ const ensureValidCommandTarget = async (props, runContext)=>{
     if (flags.all && args.messageTypeKey) {
         return _core.ux.error(`messageTypeKey arg \`${args.messageTypeKey}\` cannot also be provided when using --all`);
     }
+    // Default to knock project config first if present, otherwise cwd.
+    const messageTypesIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(projectConfig, "message_type", runCwd);
     // --all flag is given, which means no message type key arg.
     if (flags.all) {
         // If --all flag used inside a message type directory, then require a message
@@ -93,16 +96,9 @@ const ensureValidCommandTarget = async (props, runContext)=>{
         if (resourceDirCtx && !flags["message-types-dir"]) {
             return _core.ux.error("Missing required flag message-types-dir");
         }
-        // Targeting all message type dirs in the message types index dir.
-        // TODO: Default to the knock project config first if present before cwd.
-        const defaultToCwd = {
-            abspath: runCwd,
-            exists: true
-        };
-        const indexDirCtx = flags["message-types-dir"] || defaultToCwd;
         return {
             type: "messageTypesIndexDir",
-            context: indexDirCtx
+            context: flags["message-types-dir"] || messageTypesIndexDirCtx
         };
     }
     // Message type key arg is given, which means no --all flag.
@@ -110,7 +106,7 @@ const ensureValidCommandTarget = async (props, runContext)=>{
         if (resourceDirCtx && resourceDirCtx.key !== args.messageTypeKey) {
             return _core.ux.error(`Cannot run ${commandId} \`${args.messageTypeKey}\` inside another message type directory:\n${resourceDirCtx.key}`);
         }
-        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodepath.resolve(runCwd, args.messageTypeKey);
+        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodepath.resolve(messageTypesIndexDirCtx.abspath, args.messageTypeKey);
         const messageTypeDirCtx = {
             type: "message_type",
             key: args.messageTypeKey,

package/dist/lib/marshal/message-type/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./generator"), exports);
 _export_star(require("./helpers"), exports);
 _export_star(require("./processor.isomorphic"), exports);
 _export_star(require("./reader"), exports);

package/dist/lib/marshal/message-type/writer.js

@@ -12,6 +12,9 @@ _export(exports, {
     get pruneMessageTypesIndexDir () {
         return pruneMessageTypesIndexDir;
     },
+    get writeMessageTypeDirFromBundle () {
+        return writeMessageTypeDirFromBundle;
+    },
     get writeMessageTypeDirFromData () {
         return writeMessageTypeDirFromData;
     },
@@ -94,10 +97,11 @@ const writeMessageTypeDirFromData = async (messageTypeDirCtx, remoteMessageType,
             await _fsextra.emptyDir(messageTypeDirCtx.abspath);
         }
         const promises = Object.entries(messageTypeDirBundle).map(([relpath, fileContent])=>{
+            var _fileContent_toString;
             const filePath = _nodepath.resolve(messageTypeDirCtx.abspath, relpath);
             return relpath === _processorisomorphic.MESSAGE_TYPE_JSON ? _fsextra.outputJson(filePath, fileContent, {
                 spaces: _json.DOUBLE_SPACES
-            }) : _fsextra.outputFile(filePath, fileContent !== null && fileContent !== void 0 ? fileContent : "");
+            }) : _fsextra.outputFile(filePath, (_fileContent_toString = fileContent.toString()) !== null && _fileContent_toString !== void 0 ? _fileContent_toString : "");
         });
         await Promise.all(promises);
     } catch (error) {

package/dist/lib/marshal/partial/generator.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get generatePartialDir () {
+        return generatePartialDir;
+    },
+    get generatePartialFromTemplate () {
+        return generatePartialFromTemplate;
+    },
+    get scaffoldPartialDirBundle () {
+        return scaffoldPartialDirBundle;
+    },
+    get validatePartialKey () {
+        return validatePartialKey;
+    }
+});
+const _lodash = require("lodash");
+const _string = require("../../helpers/string");
+const _templates = /*#__PURE__*/ _interop_require_wildcard(require("../../templates"));
+const _constisomorphic = require("../shared/const.isomorphic");
+const _processorisomorphic = require("./processor.isomorphic");
+const _reader = require("./reader");
+const _types = require("./types");
+const _writer = require("./writer");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const validatePartialKey = (input)=>{
+    if (!(0, _string.checkSlugifiedFormat)(input, {
+        onlyLowerCase: true
+    })) {
+        return "must include only lowercase alphanumeric, dash, or underscore characters";
+    }
+    return undefined;
+};
+/*
+ * Maps the partial type to the correct file extension.
+ */ const partialTypeToFileExt = (type)=>{
+    switch(type){
+        case _types.PartialType.Html:
+            return "html";
+        case _types.PartialType.Json:
+            return "json";
+        case _types.PartialType.Markdown:
+            return "md";
+        case _types.PartialType.Text:
+        default:
+            return "txt";
+    }
+};
+/*
+ * Returns the default scaffolded content for a partial based on its type.
+ */ const defaultContentForType = (type)=>{
+    switch(type){
+        case _types.PartialType.Html:
+            return "<div>{{ content }}</div>";
+        case _types.PartialType.Json:
+            return "{}";
+        case _types.PartialType.Markdown:
+            return "**{{ content }}**";
+        case _types.PartialType.Text:
+        default:
+            return "{{ content }}";
+    }
+};
+/*
+ * Scaffolds a new partial directory bundle with default content.
+ */ const scaffoldPartialDirBundle = (attrs)=>{
+    const fileExt = partialTypeToFileExt(attrs.type);
+    const contentFilePath = `content.${fileExt}`;
+    const defaultContent = defaultContentForType(attrs.type);
+    const partialJson = {
+        name: attrs.name,
+        type: attrs.type,
+        [`content${_constisomorphic.FILEPATH_MARKER}`]: contentFilePath
+    };
+    return {
+        [_processorisomorphic.PARTIAL_JSON]: partialJson,
+        [contentFilePath]: defaultContent
+    };
+};
+const generatePartialDir = async (partialDirCtx, attrs)=>{
+    const bundle = scaffoldPartialDirBundle(attrs);
+    return (0, _writer.writePartialDirFromBundle)(partialDirCtx, bundle);
+};
+const generatePartialFromTemplate = async (partialDirCtx, templateString, attrs)=>{
+    let tempDir;
+    try {
+        // Download the template directory into a temp directory
+        tempDir = await _templates.downloadTemplate(templateString);
+        // Create a partial directory context for the temp directory
+        const tempPartialDirCtx = {
+            type: "partial",
+            key: "temp",
+            abspath: tempDir,
+            exists: true
+        };
+        // Read the partial.json from the temp directory we downloaded
+        const [partial, errors] = await (0, _reader.readPartialDir)(tempPartialDirCtx, {
+            withExtractedFiles: true
+        });
+        if (errors.length > 0 || !partial) {
+            throw new Error(`Invalid partial template: ${errors.join(", ")}`);
+        }
+        // Modify the partial data with the new attributes
+        const partialData = (0, _lodash.cloneDeep)(partial);
+        partialData.name = attrs.name;
+        // Finally, we write the partial into the target partial directory
+        await (0, _writer.writePartialDirFromData)(partialDirCtx, partialData);
+    } finally{
+        await _templates.cleanupTempDir(tempDir);
+    }
+};