@jungvonmatt/contentful-ssg 0.17.0 → 1.0.0-alpha.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Jung von Matt
+Copyright (c) 2021 Jung von Matt TECH (https://www.jvm.com/)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,4 +1,4 @@
-[![NPM version][npm-image]][npm-url] [![Build Status][ci-image]][ci-url] [![dependencies Status][depstat-image]][depstat-url] [![devDependencies Status][devdepstat-image]][devdepstat-url] [![Coverage][coveralls-image]][coveralls-url]
+[![NPM version][npm-image]][npm-url] [![Build Status][ci-image]][ci-url] [![Coverage][coveralls-image]][coveralls-url]
 
 # JvM Contentful export for static site generators
 
@@ -12,7 +12,7 @@ When a `.gitignore` file is found only ignored files are removed.
 ### Install
 
 ```bash
-npm i @jungvonmatt/contentful-ssg
+npm install --save-dev @jungvonmatt/contentful-ssg
 ```
 
 ## Commands
@@ -31,29 +31,114 @@ npx cssg init
 
 Initializes contentful-ssg and stores the config values in the `contentful-ssg.config.js` file.
 
+Contentful SSG ships with built in typescript support. Add `--typescript` to generate a typescript configuration file.
+
+```bash
+npx cssg init --typescript
+```
+
 <!-- prettier-ignore -->
 #### Configuration values
 
-| Name               | Type                           | Default       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| ------------------ | ------------------------------ | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| accessToken        | `String`                       | `undefined`   | Content Delivery API - access token                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| previewAccessToken | `String`                       | `undefined`   | Content Preview API - access token                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| spaceId            | `String`                       | `undefined`   | Contentful Space id                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| environmentId      | `String`                       | `'master'`    | Contentful Environment id                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| format             | `String`\|`Function`\|`Object` | `'yaml'`      | File format ( `yaml`, `toml`, `md`, `json`) You can add a function returning the format or you can add a mapping object like `{yaml: [glob pattern]}` ([pattern](https://github.com/micromatch/micromatch) should match the directory)                                                                                                                                                                                                                       |
-| directory          | `String`                       | `'./content'` | Base directory for content files.                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| typeConfig         | `Object`                       | `undefined`   | Pass a map with e.g. grow's blueprint config ({<contenttypeid>: {$path: '...', $view: '...'}})                                                                                                                                                                                                                                                                                                                                                               |
-| preset             | `String`                       | `undefined`   | Pass `grow` to enable generator specific addons                                                                                                                                                                                                                                                                                                                                                                                                              |
-| validate           | `Function`                     | `undefined`   | Pass `function(content, { requiredFields, requiredFieldMissing, entry, contentType, locale, ... }){...}` to validate an entry. Return a 'falsy' value to skip the entry completely. Without a validate function entries where a required field is missing are skipped.                                                                                                                                                                                       |
-| transform          | `Function`                     | `undefined`   | Pass `function(content, { entry, contentType, locale, helper, ... }){...}` to modify the stored object. Return `undefined` to skip the entry completely. (no file will be written)                                                                                                                                                                                                                                                                           |
-| mapDirectory       | `Function`                     | `undefined`   | Pass `function(contentType, { locale, helper })` to customize the directory per content-type relative to the base directory.                                                                                                                                                                                                                                                                                                                                 |
-| mapFilename        | `Function`                     | `undefined`   | Pass `function(data, { locale, contentType, entry, format, helper })` to customize the filename per entry                                                                                                                                                                                                                                                                                                                                                    |
-| mapAssetLink       | `Function`                     | `undefined`   | Pass `function(asset){...}` to customize how asset links are stored                                                                                                                                                                                                                                                                                                                                                                                          |
-| mapEntryLink       | `Function`                     | `undefined`   | Pass `function(entry){...}` to customize how entry links are stored                                                                                                                                                                                                                                                                                                                                                                                          |
-| mapMetaFields      | `Function`                     | `undefined`   | Pass `function(entry, {contentType, spaceId, locale, helper, ... }){...}` to customize the meta fields per entry                                                                                                                                                                                                                                                                                                                                             |
-| richTextRenderer   | `Object`\|`Function`           | `Boolean`     | `{}` We use the contentful [`rich-text-html-renderer`](https://github.com/contentful/rich-text/tree/master/packages/rich-text-html-renderer) to render the html.<br/> You can pass a [configuration object](https://github.com/contentful/rich-text/tree/master/packages/rich-text-html-renderer#usage)<br/> or you can pass `function(document){...}` to use your own richtext renderer or you can turn it off to get a mirrored version of the JSON output |
-| before             | `Function`                     | `undefined`   | Runs `function(context){...}` before processing the content right after pulling data from contentful                                                                                                                                                                                                                                                                                                                                                         |
-| after              | `Function`                     | `undefined`   | Runs `function(context){...}` after processing the content right before the cleanup                                                                                                                                                                                                                                                                                                                                                                          |
+| Name               | Type                            | Default       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| ------------------ | ------------------------------- | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| accessToken        | `String`                        | `undefined`   | Content Delivery API - access token                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| previewAccessToken | `String`                        | `undefined`   | Content Preview API - access token                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| spaceId            | `String`                        | `undefined`   | Contentful Space id                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| environmentId      | `String`                        | `'master'`    | Contentful Environment id                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| format             | `String`\|`Function`\|`Object`  | `'yaml'`      | File format ( `yaml`, `toml`, `md`, `json`) You can add a function returning the format or you can add a mapping object like `{yaml: [glob pattern]}` ([pattern](https://github.com/micromatch/micromatch) should match the directory)                                                                                                                                                                                                                                     |
+| directory          | `String`                        | `'./content'` | Base directory for content files.                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| validate           | `Function`                      | `undefined`   | Pass `function(transformContext, runtimeContext){...}` to validate an entry. Return `false` to skip the entry completely. Without a validate function entries with a missing required field are skipped.                                                                                                                                                                                                     |
+| transform          | `Function`                      | `undefined`   | Pass `function(transformContext, runtimeContext){...}` to modify the stored object. Return `undefined` to skip the entry completely. (no file will be written)                                                                                                                                                                                                                                                                                         |
+| mapDirectory       | `Function`                      | `undefined`   | Pass `function(transformContext, runtimeContext, defaultValue){...}` to customize the directory per content-type relative to the base directory.                                                                                                                                                                                                                                                                                                                                               |
+| mapFilename        | `Function`                      | `undefined`   | Pass `function(transformContext, runtimeContext, defaultValue){...}` to customize the filename per entry                                                                                                                                                                                                                                                                                                                                                                  |
+| mapAssetLink       | `Function`                      | `undefined`   | Pass `function(transformContext, runtimeContext, defaultValue){...}` to customize how asset links are stored                                                                                                                                                                                                                                                                                                                                                                                                        |
+| mapEntryLink       | `Function`                      | `undefined`   | Pass `function(transformContext, runtimeContext, defaultValue){...}` to customize how entry links are stored                                                                                                                                                                                                                                                                                                                                                                                                        |
+| mapMetaFields      | `Function`                      | `undefined`   | Pass `function(transformContext, runtimeContext, defaultValue){...}` to customize the meta fields per entry                                                                                                                                                                                                                                                                                                                                                           |
+| richTextRenderer   | `Boolean`\|`Object`\|`Function` | `{}`          | We use the contentful [`rich-text-html-renderer`](https://github.com/contentful/rich-text/tree/master/packages/rich-text-html-renderer) to render the html.<br/> You can pass a [configuration object](https://github.com/contentful/rich-text/tree/master/packages/rich-text-html-renderer#usage)<br/> or you can pass `function(document){...}` to use your own richtext renderer or you can turn it off by passing `false` to get a mirrored version of the JSON output |
+| before             | `Function`                      | `undefined`   | Runs `function(runtimeContext){...}` before processing the content right after pulling data from contentful                                                                                                                                                                                                                                                                                                                                                                       |
+| after              | `Function`                      | `undefined`   | Runs `function(runtimeContext){...}` after processing the content right before the cleanup                                                                                                                                                                                                                                                                                                                                                                                        |
+
+
+### Runtime Hooks
+**before**
+```js
+import
+(runtimeContext) => {
+  // Do things before processing the localized contentful entries
+  // The return value should be an object which is merged with the runtime context.
+  return { key: 'test' };
+}
+```
+
+**after**
+```js
+(runtimeContext) => {
+  // Do things after processing the localized contentful entries before cleanup
+  // We have access to values added to the context in the before hook
+  console.log(runtimeContext.key) // -> 'test'
+}
+```
+
+### Transform Hooks
+**transform**
+```js
+(transformContext, runtimeContext) => {
+  const {content} = transformContext;
+  // modify content and
+  // return object
+  return content;
+}
+```
+
+**mapFilename**
+```js
+(transformContext, runtimeContext, defaultValue) => {
+  // customize the filename on entry level
+  // return string
+  return defaultValue;
+}
+```
+
+**mapDirectory**
+```js
+(transformContext, runtimeContext, defaultValue) => {
+  // customize the directory on entry level
+  // return string
+  return defaultValue;
+}
+```
+
+**mapAssetLink**
+```js
+(transformContext, runtimeContext, defaultValue) => {
+  const {asset} = transformContext;
+  // customize the asset representation in front matter
+  // return object
+  return { ...defaultValue, ... };
+}
+```
+
+**mapEntryLink**
+```js
+(transformContext, runtimeContext, defaultValue) => {
+  const {entry} = transformContext;
+  // customize how the entry is added to your front matter
+  // return object
+  return { ...defaultValue, ... };
+}
+```
+
+**mapMetaFields**
+```js
+(transformContext, runtimeContext, defaultValue) => {
+  const {entry} = transformContext;
+  // customize how the sys meta data is added to your front matter
+  // return object
+  return { ...defaultValue, ... };
+}
+```
+
 
 #### Helper functions
 
@@ -63,9 +148,9 @@ Get values from linked pages to e.g. build an url out of parent slugs.
 
 ```js
 {
-  transform: (content, options) => {
-    const { helper } = options;
-    const slugs = helper.collectValues('fields.slug', {
+  transform: (context) => {
+    const { utils } = context;
+    const slugs = utils.collectValues('fields.slug', {
       linkField: 'fields.parentPage',
     });
 
@@ -74,8 +159,6 @@ Get values from linked pages to e.g. build an url out of parent slugs.
 }
 ```
 
-_contentful-ssg.config.js_
-
 ###### collectParentValues
 
 The same as collectValues just without the value from the current entry
@@ -92,104 +175,17 @@ npx cssg fetch
 
 ### Grow
 
-```js
-const path = require('path');
-
-module.exports = {
-  spaceId: '...',
-  environmentId: '...',
-  accessToken: '...',
-  previewAccessToken: '...',
-  directory: 'content',
-  preset: 'grow',
-  mapDirectory: (contentType) => {
-    switch (contentType.substr(0, 2)) {
-      case 't-':
-        return contentType;
-      case 'o-':
-        return path.join('partials/organisms', contentType);
-      case 'm-':
-        return path.join('partials/molecules', contentType);
-      case 'a-':
-        return path.join('partials/atoms', contentType);
-      default:
-        return path.join('partials', contentType);
-    }
-  },
-  typeConfig: {
-    't-home': {
-      view: '/views/t-home.html',
-      path: '/{locale}/',
-    },
-    't-article': {
-      view: '/views/t-article.html',
-      path: '/{locale}/{category}/{slug}/',
-    },
-  },
-};
-```
+See [`cssg-plugin-grow`](../cssg-plugin-grow)
 
-### Hugo
 
-```js
-const path = require('path');
-
-module.exports = {
-  spaceId: '...',
-  environmentId: '...',
-  accessToken: '...',
-  previewAccessToken: '...',
-  directory: 'content',
-  format: 'md',
-  mapDirectory: function (contentType, { locale, helper }) {
-    if (contentType === 't-home') {
-      return '/';
-    } else if (contentType.substr(0, 2) === 't-') {
-      return 'pages';
-    } else {
-      return path.join('headlessBundles', contentType);
-    }
-  },
-  mapFilename: function (data, { locale, contentType, entry, format, helper }) {
-    if (contentType === 't-home') {
-      return path.join('_index.' + locale.code + '.' + format);
-    } else {
-      return path.join(entry.sys.id + '/index.' + locale.code + '.' + format);
-    }
-  },
-  transform: (content, options) => {
-    const { helper } = options;
-    const slugs = helper.collectValues('fields.slug', {
-      linkField: 'fields.parentPage',
-    });
-    if (content.contentType === 't-home') {
-      return { ...content };
-    } else if (content.contentType.substr(0, 2) === 't-') {
-      return { ...content, url: slugs.join('/') };
-    } else {
-      return { ...content, headless: true };
-    }
-  },
-};
-```
-
-## Demo
-
-![Demo](https://github.com/jungvonmatt/contentful-ssg/blob/main/demo.gif?raw=true)
+### Hugo
 
-## Can I contribute?
+See [`cssg-plugin-hugo`](../cssg-plugin-hugo)
 
-Of course. We appreciate all of our [contributors](https://github.com/jungvonmatt/contentful-ssg/graphs/contributors) and
-welcome contributions to improve the project further. If you're uncertain whether an addition should be made, feel
-free to open up an issue and we can discuss it.
 
 [npm-url]: https://www.npmjs.com/package/@jungvonmatt/contentful-ssg
 [npm-image]: https://img.shields.io/npm/v/@jungvonmatt/contentful-ssg.svg
 [ci-url]: https://github.com/jungvonmatt/contentful-ssg/actions?workflow=Tests
 [ci-image]: https://github.com/jungvonmatt/contentful-ssg/workflows/Tests/badge.svg
-[depstat-url]: https://david-dm.org/jungvonmatt/contentful-ssg
-[depstat-image]: https://img.shields.io/david/jungvonmatt/contentful-ssg.svg
-[devdepstat-url]: https://david-dm.org/jungvonmatt/contentful-ssg?type=dev
-[devdepstat-image]: https://img.shields.io/david/dev/jungvonmatt/contentful-ssg.svg
 [coveralls-url]: https://coveralls.io/github/jungvonmatt/contentful-ssg?branch=main
 [coveralls-image]: https://coveralls.io/repos/github/jungvonmatt/contentful-ssg/badge.svg?branch=main

package/dist/__test__/mock.d.ts

@@ -0,0 +1,28 @@
+import type { Config, RuntimeContext, TransformContext } from '../types.js';
+export declare const readFixture: (file: any) => Promise<any>;
+export declare const readFixtureSync: (file: any) => any;
+export declare const getContent: () => Promise<{
+    entries: any;
+    assets: any;
+    contentTypes: any;
+    locales: any;
+    assetLink: {
+        sys: {
+            id: string;
+            type: string;
+            linkType: string;
+        };
+    };
+    entryLink: {
+        sys: {
+            id: string;
+            type: string;
+            linkType: string;
+        };
+    };
+    entry: any;
+    asset: any;
+}>;
+export declare const getConfig: (fixture?: Partial<Config>) => Config;
+export declare const getRuntimeContext: (fixture?: Partial<RuntimeContext>) => RuntimeContext;
+export declare const getTransformContext: (fixture?: Partial<TransformContext>) => TransformContext;

package/dist/__test__/mock.js

@@ -0,0 +1,83 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { FIELD_TYPE_LINK, getFieldSettings, LINK_TYPE_ASSET, LINK_TYPE_ENTRY, } from '../lib/contentful.js';
+import { FileManager } from '../lib/file-manager.js';
+import { HookManager } from '../lib/hook-manager.js';
+const cache = new Map();
+export const readFixture = async (file) => {
+    if (!cache.has(file)) {
+        const content = await fs.readJSON(path.join(__dirname, 'fixtures', file));
+        cache.set(file, content);
+    }
+    return cache.get(file);
+};
+export const readFixtureSync = (file) => {
+    if (!cache.has(file)) {
+        const content = fs.readJSONSync(path.join(__dirname, 'fixtures', file));
+        cache.set(file, content);
+    }
+    return cache.get(file);
+};
+export const getContent = async () => {
+    const assets = await readFixture('assets.json');
+    const entries = await readFixture('entries.json');
+    const locales = await readFixture('locales.json');
+    const contentTypes = await readFixture('content_types.json');
+    const [entry] = entries;
+    const [asset] = assets;
+    const assetLink = {
+        sys: {
+            id: 'asset-id',
+            type: FIELD_TYPE_LINK,
+            linkType: LINK_TYPE_ASSET,
+        },
+    };
+    const entryLink = {
+        sys: {
+            id: 'entry-id',
+            type: FIELD_TYPE_LINK,
+            linkType: LINK_TYPE_ENTRY,
+        },
+    };
+    return { entries, assets, contentTypes, locales, assetLink, entryLink, entry, asset };
+};
+export const getConfig = (fixture = {}) => ({
+    directory: 'test',
+    plugins: [],
+    ...fixture,
+});
+export const getRuntimeContext = (fixture = {}) => {
+    const assets = readFixtureSync('assets.json');
+    const entries = readFixtureSync('entries.json');
+    const locales = readFixtureSync('locales.json');
+    const contentTypes = readFixtureSync('content_types.json');
+    const fieldSettings = getFieldSettings(contentTypes);
+    const { code: defaultLocale } = locales.find((locale) => locale.default) || locales[0];
+    const result = {
+        config: getConfig(),
+        localized: new Map(),
+        data: {
+            assets,
+            entries,
+            contentTypes,
+            locales,
+            fieldSettings,
+        },
+        defaultLocale,
+        ...fixture,
+    };
+    const hooks = new HookManager(result, result.config);
+    const fileManager = new FileManager({ directory: '/testbase' });
+    fileManager.cleanup = jest.fn();
+    fileManager.initialize = jest.fn();
+    fileManager.deleteFile = jest.fn();
+    fileManager.writeFile = jest.fn();
+    return { ...result, hooks, fileManager };
+};
+export const getTransformContext = (fixture = {}) => ({
+    assets: [],
+    entries: [],
+    assetMap: new Map(),
+    entryMap: new Map(),
+    ...fixture,
+});

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import path from 'path';
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+import { outputFile } from 'fs-extra';
+import prettier from 'prettier';
+import { Command } from 'commander';
+import dotenv from 'dotenv';
+import dotenvExpand from 'dotenv-expand';
+import { logError, confirm, askAll, askMissing } from './lib/ui.js';
+import { omitKeys } from './lib/object.js';
+import { getConfig, getEnvironmentConfig } from './lib/config.js';
+import { run } from './index.js';
+const env = dotenv.config();
+dotenvExpand(env);
+const parseArgs = (cmd) => ({
+    environment: cmd.env,
+    preview: Boolean(cmd.preview),
+    verbose: Boolean(cmd.verbose),
+});
+const errorHandler = (error, silence) => {
+    if (!silence) {
+        const { errors } = error;
+        logError(error);
+        (errors || []).forEach((error) => {
+            logError(error);
+        });
+    }
+    process.exit(1);
+};
+const actionRunner = (fn, log = true) => (...args) => fn(...args).catch((error) => errorHandler(error, !log));
+const program = new Command();
+program
+    .command('init')
+    .description('Initialize contentful-ssg')
+    .option('--typescript', 'Initialize typescript config')
+    .action(actionRunner(async (cmd) => {
+    const useTypescript = Boolean(cmd?.typescript ?? false);
+    const config = await getConfig(parseArgs(cmd || {}));
+    const verified = await askAll(config);
+    const environmentConfig = getEnvironmentConfig();
+    const filePath = path.join(process.cwd(), `contentful-ssg.config.${useTypescript ? 'ts' : 'js'}`);
+    const prettierOptions = await prettier.resolveConfig(filePath);
+    if (verified.directory?.startsWith('/')) {
+        verified.directory = path.relative(process.cwd(), verified.directory);
+    }
+    const environmentKeys = Object.keys(environmentConfig).filter((key) => environmentConfig[key] === verified[key]);
+    const cleanedConfig = omitKeys(verified, 'preview', 'verbose', 'rootDir', 'resolvedPlugins', 'host', 'managementToken', ...environmentKeys);
+    let content = '';
+    if (useTypescript) {
+        content = prettier.format(`import {Config} from '@jungvonmatt/contentful-ssg';
+        export default <Config>${JSON.stringify(cleanedConfig)}`, {
+            parser: 'typescript',
+            ...prettierOptions,
+        });
+    }
+    else {
+        content = prettier.format(`module.exports = ${JSON.stringify(cleanedConfig)}`, {
+            parser: 'babel',
+            ...prettierOptions,
+        });
+    }
+    let writeFile = true;
+    if (existsSync(filePath)) {
+        writeFile = await confirm(`Config file already exists. Overwrite?\n\n${chalk.reset(content)}`);
+    }
+    else {
+        writeFile = await confirm(`Please verify your settings:\n\n${chalk.reset(content)}`, true);
+    }
+    if (writeFile) {
+        await outputFile(filePath, content);
+        console.log(`\nConfiguration saved to ${chalk.cyan(path.relative(process.cwd(), filePath))}`);
+    }
+}));
+program
+    .command('fetch')
+    .description('Fetch content objects')
+    .option('-p, --preview', 'Fetch with preview mode')
+    .option('-v, --verbose', 'Verbose output')
+    .action(actionRunner(async (cmd) => {
+    const config = await getConfig(parseArgs(cmd || {}));
+    const verified = await askMissing(config);
+    return run(verified);
+}));
+program.parse(process.argv);

package/dist/converter/index.d.ts

@@ -0,0 +1,7 @@
+import { KeyValueMap } from '../types.js';
+export declare const TYPE_JSON = "json";
+export declare const TYPE_YAML = "yaml";
+export declare const TYPE_MARKDOWN = "markdown";
+export declare const TYPE_TOML = "toml";
+export declare const stringify: <T = KeyValueMap<any>>(obj: T, format?: string) => string;
+export declare const parse: (str: string, format?: string) => KeyValueMap<any>;

package/dist/converter/index.js

@@ -0,0 +1,42 @@
+import { stringify as stringifyJson, parse as parseJson } from './json.js';
+import { stringify as stringifyMarkdown, parse as parseMarkdown } from './markdown.js';
+import { stringify as stringifyToml, parse as parseToml } from './toml.js';
+import { stringify as stringifyYaml, parse as parseYaml } from './yaml.js';
+export const TYPE_JSON = 'json';
+export const TYPE_YAML = 'yaml';
+export const TYPE_MARKDOWN = 'markdown';
+export const TYPE_TOML = 'toml';
+export const stringify = (obj, format = 'yaml') => {
+    switch (format) {
+        case 'yml':
+        case TYPE_YAML:
+            return stringifyYaml(obj);
+        case 'md':
+        case TYPE_MARKDOWN:
+            return stringifyMarkdown(obj);
+        case TYPE_JSON:
+            return stringifyJson(obj);
+        case TYPE_TOML:
+            return stringifyToml(obj);
+        default:
+            throw new Error(`Format ${JSON.stringify(format)} is not supported`);
+    }
+};
+export const parse = (str, format = 'yaml') => {
+    switch (format) {
+        case 'yml':
+        case TYPE_YAML:
+            return parseYaml(str);
+        case 'md':
+        case TYPE_MARKDOWN: {
+            const { data } = parseMarkdown(str);
+            return data;
+        }
+        case TYPE_JSON:
+            return parseJson(str);
+        case TYPE_TOML:
+            return parseToml(str);
+        default:
+            throw new Error(`Format "${format}" is not supported`);
+    }
+};

package/dist/converter/json.d.ts

@@ -0,0 +1,3 @@
+import { KeyValueMap } from '../types';
+export declare const stringify: <T = KeyValueMap<any>>(obj: T) => string;
+export declare const parse: <T = KeyValueMap<any>>(string: string) => T;

package/dist/converter/json.js

@@ -0,0 +1,2 @@
+export const stringify = (obj) => JSON.stringify(obj, null, '  ');
+export const parse = (string) => JSON.parse(string);

package/dist/converter/markdown.d.ts

@@ -0,0 +1,3 @@
+import { KeyValueMap } from '../types.js';
+export declare const stringify: <T = KeyValueMap<any>>(obj: T, content?: string) => string;
+export declare const parse: <T = KeyValueMap<any>>(string: string) => T;

package/dist/converter/markdown.js

@@ -0,0 +1,17 @@
+import matter from 'gray-matter';
+import { stringify as stringifyYaml, parse as parseYaml } from './yaml.js';
+export const stringify = (obj, content = '') => {
+    let frontMatter = '';
+    frontMatter += '---\n';
+    frontMatter += stringifyYaml(obj);
+    frontMatter += `---\n${content}`;
+    return frontMatter;
+};
+export const parse = (string) => {
+    const data = matter(string, {
+        engines: {
+            yaml: (string) => parseYaml(string),
+        },
+    });
+    return data;
+};

package/dist/converter/toml.d.ts

@@ -0,0 +1,3 @@
+import { KeyValueMap } from '../types';
+export declare const stringify: <T = KeyValueMap<any>>(obj: T) => string;
+export declare const parse: <T = KeyValueMap<any>>(string: string) => T;

package/dist/converter/toml.js

@@ -0,0 +1,3 @@
+import TOML from '@iarna/toml';
+export const stringify = (obj) => TOML.stringify(obj);
+export const parse = (string) => TOML.parse(string);

package/dist/converter/yaml.d.ts

@@ -0,0 +1,3 @@
+import { KeyValueMap } from '../types';
+export declare const stringify: <T = KeyValueMap<any>>(obj: T) => string;
+export declare const parse: <T = KeyValueMap<any>>(obj: string) => T;

package/dist/converter/yaml.js

@@ -0,0 +1,27 @@
+import yaml from 'js-yaml';
+const getPredicate = (type) => (data) => typeof data === 'string' && data.startsWith(`${type} `);
+const getRepresent = (type) => (data) => typeof data === 'string' ? data.replace(`${type} `, '') : JSON.stringify(data);
+const getConstruct = (type) => (data) => typeof data === 'string' ? `${type} ${data}` : `${type} ${typeof data}`;
+const growYamlConstructors = [
+    '!g.csv',
+    '!g.doc',
+    '!g.json',
+    '!g.static',
+    '!g.string',
+    '!g.url',
+    '!g.yaml',
+];
+const growYamlTypes = growYamlConstructors.map((type) => new yaml.Type(type, {
+    kind: 'scalar',
+    predicate: getPredicate(type),
+    represent: getRepresent(type),
+    construct: getConstruct(type),
+}));
+export const stringify = (obj) => {
+    const GROW_SCHEMA = yaml.DEFAULT_SCHEMA.extend(growYamlTypes);
+    return yaml.dump(obj, { schema: GROW_SCHEMA });
+};
+export const parse = (obj) => {
+    const GROW_SCHEMA = yaml.DEFAULT_SCHEMA.extend(growYamlTypes);
+    return yaml.load(obj, { schema: GROW_SCHEMA });
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from './types.js';
+export declare const run: (config: Config) => Promise<void>;