@sitecore-content-sdk/core 0.1.0-beta.16 → 0.1.0-beta.18

package/dist/cjs/tools/index.js

@@ -1,4 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scaffoldComponent = exports.generateMetadata = exports.generateSites = void 0;
 var generateSites_1 = require("./generateSites");
@@ -7,3 +21,4 @@ var generateMetadata_1 = require("./generateMetadata");
 Object.defineProperty(exports, "generateMetadata", { enumerable: true, get: function () { return generateMetadata_1.generateMetadata; } });
 var scaffold_1 = require("./scaffold");
 Object.defineProperty(exports, "scaffoldComponent", { enumerable: true, get: function () { return scaffold_1.scaffoldComponent; } });
+__exportStar(require("./templating"), exports);

package/dist/cjs/tools/templating/components.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponentList = getComponentList;
+const utils_1 = require("./utils");
+/**
+ * Get list of components from @var path
+ * Returns a list of components in the following format:
+ * {
+ *  path: 'path/to/component',
+ *  componentName: 'ComponentName',
+ *  moduleName: 'ComponentName'
+ * }
+ * @param {string} path path to search
+ */
+function getComponentList(path) {
+    const components = (0, utils_1.getItems)({
+        path,
+        resolveItem: (path, name) => ({
+            path: `${path}/${name}`,
+            componentName: name,
+            moduleName: name.replace(/[^\w]+/g, ''),
+        }),
+        cb: (name) => console.debug(`Registering JSS component ${name}`),
+    });
+    return components;
+}

package/dist/cjs/tools/templating/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleType = exports.generatePlugins = exports.getComponentList = void 0;
+var components_1 = require("./components");
+Object.defineProperty(exports, "getComponentList", { enumerable: true, get: function () { return components_1.getComponentList; } });
+var plugins_1 = require("./plugins");
+Object.defineProperty(exports, "generatePlugins", { enumerable: true, get: function () { return plugins_1.generatePlugins; } });
+Object.defineProperty(exports, "ModuleType", { enumerable: true, get: function () { return plugins_1.ModuleType; } });

package/dist/cjs/tools/templating/plugins.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleType = void 0;
+exports.getPluginList = getPluginList;
+exports.generatePlugins = generatePlugins;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+/**
+ * Identifies the format of the module to be compiled
+ */
+var ModuleType;
+(function (ModuleType) {
+    ModuleType[ModuleType["CJS"] = 0] = "CJS";
+    ModuleType[ModuleType["ESM"] = 1] = "ESM";
+})(ModuleType || (exports.ModuleType = ModuleType = {}));
+/**
+ * Get list of plugins from @var path
+ * Returns a list of plugins in the following format:
+ * {
+ *   path: 'path/to/plugin/foo',
+ *   name: 'fooPlugin'
+ * }
+ * @example getPluginList('src/foo/plugins', 'Foo')
+ * @param {object} definition plugin definition
+ * @param {string} definition.path path to get plugin from
+ * @param {string} definition.pluginName plugin name
+ * @param {boolean} [definition.silent] whether to suppress console output
+ */
+function getPluginList({ path, pluginName, silent = false, }) {
+    const plugins = (0, utils_1.getItems)({
+        path,
+        resolveItem: (path, name) => ({
+            path: `${path}/${name}`,
+            name: `${name.replace(/-./g, (x) => x[1].toUpperCase())}Plugin`,
+        }),
+        cb: (name) => !silent && console.debug(`Registering ${pluginName} plugin ${name}`),
+    });
+    return plugins;
+}
+/**
+ * Generates the plugins file and saves it to the filesystem.
+ * By convention, we expect to find plugins under {pluginName}/plugins/** (subfolders are searched recursively).
+ * generated file will be saved to @var {distPath} and will contain a list of plugins in the following format:
+ * CJS: exports.fooPlugin = require('{pluginPath}');
+ * ESM: export { fooPlugin } from '{pluginPath}';
+ * @example generatePlugins({ distPath: 'src/temp/foo-plugins.js', rootPath: 'src/foo/plugins', moduleType: ModuleType.CJS })
+ * @param {PluginDefinition} definition plugin definition
+ */
+function generatePlugins(definition) {
+    const { rootPath, distPath, moduleType, relative = false, silent } = definition;
+    const segments = rootPath.split('/');
+    const pluginName = segments[segments.length - 2];
+    const plugins = getPluginList({ path: rootPath, pluginName, silent });
+    let fileContent = '';
+    fileContent = plugins
+        .map((plugin) => {
+        const sourcePath = relative
+            ? path_1.default.relative(path_1.default.dirname(distPath), plugin.path).replace(/\\/g, '/')
+            : plugin.path;
+        return moduleType === ModuleType.CJS
+            ? `exports.${plugin.name} = require('${sourcePath}');`
+            : `export { ${plugin.name} } from '${sourcePath}';`;
+    })
+        .join('\r\n')
+        .concat('\r\n');
+    if (!plugins.length) {
+        fileContent = moduleType === ModuleType.CJS ? 'module.exports = {};\r\n' : 'export {};\r\n';
+    }
+    const filePath = path_1.default.resolve(distPath);
+    !silent && console.log(`Writing ${pluginName} plugins to ${filePath}`);
+    fs_1.default.writeFileSync(filePath, fileContent, {
+        encoding: 'utf8',
+    });
+}

package/dist/cjs/tools/templating/utils.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getItems = getItems;
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Using @var path find all files and generate output using @var resolveItem function for each file
+ * Can be used to generate list of components, templates, etc.
+ * @param {GetItemsSettings} settings
+ * @returns {Item[]} list of items
+ */
+function getItems(settings) {
+    const { recursive = true, path, resolveItem, cb, fileFormat = new RegExp(/(.+)(?<!\.d)\.[jt]sx?$/), } = settings;
+    const items = [];
+    const folders = [];
+    if (!fs_1.default.existsSync(path))
+        return [];
+    fs_1.default.readdirSync(path, { withFileTypes: true }).forEach((item) => {
+        if (item.isDirectory()) {
+            folders.push(item);
+        }
+        if (fileFormat.test(item.name)) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const name = item.name.match(fileFormat)[1];
+            items.push(resolveItem(path, name));
+            cb && cb(name);
+        }
+    });
+    for (const folder of folders) {
+        recursive
+            ? items.push(...getItems({
+                path: `${path}/${folder.name}`,
+                resolveItem,
+                cb,
+                fileFormat,
+            }))
+            : items.push(resolveItem(`${path}/${folder.name}`, folder.name));
+    }
+    return items;
+}

package/dist/esm/tools/index.js

@@ -1,3 +1,4 @@
 export { generateSites } from './generateSites';
 export { generateMetadata } from './generateMetadata';
 export { scaffoldComponent } from './scaffold';
+export * from './templating';

package/dist/esm/tools/templating/components.js

@@ -0,0 +1,23 @@
+import { getItems } from './utils';
+/**
+ * Get list of components from @var path
+ * Returns a list of components in the following format:
+ * {
+ *  path: 'path/to/component',
+ *  componentName: 'ComponentName',
+ *  moduleName: 'ComponentName'
+ * }
+ * @param {string} path path to search
+ */
+export function getComponentList(path) {
+    const components = getItems({
+        path,
+        resolveItem: (path, name) => ({
+            path: `${path}/${name}`,
+            componentName: name,
+            moduleName: name.replace(/[^\w]+/g, ''),
+        }),
+        cb: (name) => console.debug(`Registering JSS component ${name}`),
+    });
+    return components;
+}

package/dist/esm/tools/templating/index.js

@@ -0,0 +1,2 @@
+export { getComponentList } from './components';
+export { generatePlugins, ModuleType } from './plugins';

package/dist/esm/tools/templating/plugins.js

@@ -0,0 +1,70 @@
+import fs from 'fs';
+import path from 'path';
+import { getItems } from './utils';
+/**
+ * Identifies the format of the module to be compiled
+ */
+export var ModuleType;
+(function (ModuleType) {
+    ModuleType[ModuleType["CJS"] = 0] = "CJS";
+    ModuleType[ModuleType["ESM"] = 1] = "ESM";
+})(ModuleType || (ModuleType = {}));
+/**
+ * Get list of plugins from @var path
+ * Returns a list of plugins in the following format:
+ * {
+ *   path: 'path/to/plugin/foo',
+ *   name: 'fooPlugin'
+ * }
+ * @example getPluginList('src/foo/plugins', 'Foo')
+ * @param {object} definition plugin definition
+ * @param {string} definition.path path to get plugin from
+ * @param {string} definition.pluginName plugin name
+ * @param {boolean} [definition.silent] whether to suppress console output
+ */
+export function getPluginList({ path, pluginName, silent = false, }) {
+    const plugins = getItems({
+        path,
+        resolveItem: (path, name) => ({
+            path: `${path}/${name}`,
+            name: `${name.replace(/-./g, (x) => x[1].toUpperCase())}Plugin`,
+        }),
+        cb: (name) => !silent && console.debug(`Registering ${pluginName} plugin ${name}`),
+    });
+    return plugins;
+}
+/**
+ * Generates the plugins file and saves it to the filesystem.
+ * By convention, we expect to find plugins under {pluginName}/plugins/** (subfolders are searched recursively).
+ * generated file will be saved to @var {distPath} and will contain a list of plugins in the following format:
+ * CJS: exports.fooPlugin = require('{pluginPath}');
+ * ESM: export { fooPlugin } from '{pluginPath}';
+ * @example generatePlugins({ distPath: 'src/temp/foo-plugins.js', rootPath: 'src/foo/plugins', moduleType: ModuleType.CJS })
+ * @param {PluginDefinition} definition plugin definition
+ */
+export function generatePlugins(definition) {
+    const { rootPath, distPath, moduleType, relative = false, silent } = definition;
+    const segments = rootPath.split('/');
+    const pluginName = segments[segments.length - 2];
+    const plugins = getPluginList({ path: rootPath, pluginName, silent });
+    let fileContent = '';
+    fileContent = plugins
+        .map((plugin) => {
+        const sourcePath = relative
+            ? path.relative(path.dirname(distPath), plugin.path).replace(/\\/g, '/')
+            : plugin.path;
+        return moduleType === ModuleType.CJS
+            ? `exports.${plugin.name} = require('${sourcePath}');`
+            : `export { ${plugin.name} } from '${sourcePath}';`;
+    })
+        .join('\r\n')
+        .concat('\r\n');
+    if (!plugins.length) {
+        fileContent = moduleType === ModuleType.CJS ? 'module.exports = {};\r\n' : 'export {};\r\n';
+    }
+    const filePath = path.resolve(distPath);
+    !silent && console.log(`Writing ${pluginName} plugins to ${filePath}`);
+    fs.writeFileSync(filePath, fileContent, {
+        encoding: 'utf8',
+    });
+}

package/dist/esm/tools/templating/utils.js

@@ -0,0 +1,36 @@
+import fs from 'fs';
+/**
+ * Using @var path find all files and generate output using @var resolveItem function for each file
+ * Can be used to generate list of components, templates, etc.
+ * @param {GetItemsSettings} settings
+ * @returns {Item[]} list of items
+ */
+export function getItems(settings) {
+    const { recursive = true, path, resolveItem, cb, fileFormat = new RegExp(/(.+)(?<!\.d)\.[jt]sx?$/), } = settings;
+    const items = [];
+    const folders = [];
+    if (!fs.existsSync(path))
+        return [];
+    fs.readdirSync(path, { withFileTypes: true }).forEach((item) => {
+        if (item.isDirectory()) {
+            folders.push(item);
+        }
+        if (fileFormat.test(item.name)) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const name = item.name.match(fileFormat)[1];
+            items.push(resolveItem(path, name));
+            cb && cb(name);
+        }
+    });
+    for (const folder of folders) {
+        recursive
+            ? items.push(...getItems({
+                path: `${path}/${folder.name}`,
+                resolveItem,
+                cb,
+                fileFormat,
+            }))
+            : items.push(resolveItem(`${path}/${folder.name}`, folder.name));
+    }
+    return items;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sitecore-content-sdk/core",
-  "version": "0.1.0-beta.16",
+  "version": "0.1.0-beta.18",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "sideEffects": false,
@@ -67,7 +67,7 @@
   },
   "description": "",
   "types": "types/index.d.ts",
-  "gitHead": "6ad14b74f9e5a1e88e14289a16de1bd25de5cc74",
+  "gitHead": "1edf1b0efcb6445d6f989542097a419e3410e61f",
   "files": [
     "dist",
     "types",

package/types/tools/index.d.ts

@@ -1,3 +1,4 @@
 export { generateSites, GenerateSitesConfig } from './generateSites';
 export { generateMetadata } from './generateMetadata';
 export { scaffoldComponent } from './scaffold';
+export * from './templating';

package/types/tools/templating/components.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Describes a file that represents a component definition
+ */
+export interface ComponentFile {
+    path: string;
+    moduleName: string;
+    componentName: string;
+}
+/**
+ * Describes a package and components to be imported
+ */
+export interface PackageDefinition {
+    name: string;
+    components: {
+        moduleName: string;
+        componentName: string;
+    }[];
+}
+/**
+ * Get list of components from @var path
+ * Returns a list of components in the following format:
+ * {
+ *  path: 'path/to/component',
+ *  componentName: 'ComponentName',
+ *  moduleName: 'ComponentName'
+ * }
+ * @param {string} path path to search
+ */
+export declare function getComponentList(path: string): ComponentFile[];

package/types/tools/templating/index.d.ts

@@ -0,0 +1,2 @@
+export { ComponentFile, PackageDefinition, getComponentList } from './components';
+export { PluginDefinition, generatePlugins, ModuleType } from './plugins';

package/types/tools/templating/plugins.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Identifies the format of the module to be compiled
+ */
+export declare enum ModuleType {
+    CJS = 0,
+    ESM = 1
+}
+/**
+ * Type to specify plugin file details
+ */
+export interface PluginFile {
+    path: string;
+    name: string;
+}
+/**
+ * Definition to be used for plugin registration during bootstrap
+ */
+export interface PluginDefinition {
+    /**
+     * destination path to compile plugins to
+     */
+    distPath: string;
+    /**
+     * source path for where the plugins are defined
+     */
+    rootPath: string;
+    /**
+     * CJS or ESM - which type to compile plugins to
+     */
+    moduleType: ModuleType;
+    /**
+     * whether to use relative or absolute paths in the generated file. By default, absolute paths are used.
+     */
+    relative?: boolean;
+    /**
+     * whether to suppress console output
+     */
+    silent?: boolean;
+}
+/**
+ * Get list of plugins from @var path
+ * Returns a list of plugins in the following format:
+ * {
+ *   path: 'path/to/plugin/foo',
+ *   name: 'fooPlugin'
+ * }
+ * @example getPluginList('src/foo/plugins', 'Foo')
+ * @param {object} definition plugin definition
+ * @param {string} definition.path path to get plugin from
+ * @param {string} definition.pluginName plugin name
+ * @param {boolean} [definition.silent] whether to suppress console output
+ */
+export declare function getPluginList({ path, pluginName, silent, }: {
+    path: string;
+    pluginName: string;
+    silent?: boolean;
+}): PluginFile[];
+/**
+ * Generates the plugins file and saves it to the filesystem.
+ * By convention, we expect to find plugins under {pluginName}/plugins/** (subfolders are searched recursively).
+ * generated file will be saved to @var {distPath} and will contain a list of plugins in the following format:
+ * CJS: exports.fooPlugin = require('{pluginPath}');
+ * ESM: export { fooPlugin } from '{pluginPath}';
+ * @example generatePlugins({ distPath: 'src/temp/foo-plugins.js', rootPath: 'src/foo/plugins', moduleType: ModuleType.CJS })
+ * @param {PluginDefinition} definition plugin definition
+ */
+export declare function generatePlugins(definition: PluginDefinition): void;

package/types/tools/templating/utils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Settings for @var getItems function
+ */
+export type GetItemsSettings<Item> = {
+    /**
+     * items path
+     */
+    path: string;
+    /**
+     * Resolve item in required data format
+     */
+    resolveItem: (path: string, name: string) => Item;
+    /**
+     * Will be called when new file is found
+     */
+    cb?: (name: string) => void;
+    /**
+     * Matches specific files format
+     */
+    fileFormat?: RegExp;
+    /**
+     * Wether to search recursively
+     */
+    recursive?: boolean;
+};
+/**
+ * Using @var path find all files and generate output using @var resolveItem function for each file
+ * Can be used to generate list of components, templates, etc.
+ * @param {GetItemsSettings} settings
+ * @returns {Item[]} list of items
+ */
+export declare function getItems<Item>(settings: GetItemsSettings<Item>): Item[];