@podlite/publisher 0.0.2

package/lib/plugins.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composePlugins = exports.processPlugin = exports.filterFiles = void 0;
+/**
+=begin pod
+=head1 filterFiles
+
+This function filters an array of file names based on provided include and exclude patterns. It first converts the includePatterns and excludePatterns arguments into arrays, if they aren't already. The function then filters through the files array, including a file if it matches any of the include patterns (or if no include patterns are provided) and excluding it if it matches any of the exclude patterns. The function returns a new array containing the files that match the include criteria and do not match the exclude criteria.
+
+=head2 Parameters
+
+  =begin item
+  B<files>
+  
+  An array of strings, each representing a file name to be filtered.
+  =end item
+  =begin item
+  B<includePatterns>
+  
+  Optional. A string or an array of strings representing the pattern(s) files must match to be included. If not provided, all files are considered to match the include criteria.
+  =end item
+  =begin item
+  B<excludePatterns>
+  
+  Optional. A string or an array of strings representing the pattern(s) files must match to be excluded. If not provided, no files are excluded based on patterns.
+  =end item
+
+=head2 Returns
+
+An array of strings, each representing a file name that matched the include criteria and did not match the exclude criteria.
+
+=end pod
+*/
+function filterFiles(files, includePatterns, excludePatterns) {
+    const patternArray = includePatterns ? (Array.isArray(includePatterns) ? includePatterns : [includePatterns]) : ['.*'];
+    const excludePatternArray = excludePatterns
+        ? Array.isArray(excludePatterns)
+            ? excludePatterns
+            : [excludePatterns]
+        : [];
+    return files.filter(file => {
+        const include = patternArray.length === 0 ? true : patternArray.some(pattern => new RegExp(pattern).test(file));
+        const exclude = excludePatternArray.length === 0 ? false : excludePatternArray.some(pattern => new RegExp(pattern).test(file));
+        return include && !exclude;
+    });
+}
+exports.filterFiles = filterFiles;
+/**
+=begin pod
+=head1 processPlugin
+
+The function `processPlugin` processes a collection of publishing records based on a given
+plugin configuration. It filters the items to determine which ones match specified inclusion
+and exclusion patterns. Items that match are processed by the provided plugin function, while
+ items that do not match are passed through unchanged. Finally, it returns a tuple containing
+ the processed items and the result of calling the `onClose` function with a context object.
+
+=head2 Parameters
+
+  =begin item
+  B<pluginConf>
+  
+  An object of type `PluginConfig` that provides configuration for the plugin, including
+  the plugin processing function, inclusion patterns, and exclusion patterns.
+  =end item
+  =begin item
+  B<items>
+  
+  An array of `publishRecord` objects representing the items to be processed by the plugin.
+  =end item
+
+=head2 Returns
+
+A tuple where the first element is an array of `publishRecord` objects representing
+the processed and unprocessed items, and the second element is an object resulting
+from calling the plugin's `onClose` function with a context object. This object may
+contain arbitrary data based on the plugin's implementation.
+
+=end pod
+*/
+const processPlugin = (pluginConf, items, ctx = {}) => {
+    const [processItems, onClose] = pluginConf.plugin;
+    // process items
+    const allPaths = items.map(i => i.file);
+    const matchedPaths = filterFiles(allPaths, pluginConf.includePatterns || '.*', pluginConf.excludePatterns || []);
+    const matchedItems = items.filter(i => matchedPaths.includes(i.file));
+    const notMatchedPaths = allPaths.filter(i => !matchedPaths.includes(i));
+    const notMatchedItems = items.filter(i => notMatchedPaths.includes(i.file));
+    const nextState = [...notMatchedItems, ...processItems(matchedItems)];
+    return [nextState, onClose(ctx)];
+};
+exports.processPlugin = processPlugin;
+/**
+=begin pod
+=head1 composePlugins
+
+This function takes an array of PluginConfig objects and combines them into a single PluginConfig.
+It does this by sequentially processing each PluginConfig in the array with the next,
+effectively composing their behaviors into a single plugin configuration.
+Each PluginConfig is expected to modify a shared state and context. The composition
+is achieved by chaining the plugin functions within each PluginConfig, so that the
+output (both state and context) of one plugin function becomes the input to the next.
+
+=head2 Parameters
+
+  =begin item
+  B<configs>
+  
+  An array of PluginConfig objects. Each PluginConfig is an object that represents
+  configuration for a plugin, which includes a plugin processing function and
+  potentially other settings.
+  =end item
+
+=head2 Returns
+
+Returns a single PluginConfig object that represents the composed configuration
+of all the PluginConfig objects passed in the 'configs' array. This resulting
+PluginConfig can be used to process items with the combined logic of all the
+plugins defined in the input array.
+
+=end pod
+*/
+const composePlugins = (configs, inintCtx = {}) => {
+    const result = configs.reduce((acc, config) => {
+        if (acc.config?.plugin) {
+            const accCtx = acc.ctx || {};
+            let resultCtx = {};
+            const resultConfig = {
+                plugin: [
+                    items => {
+                        const [processedAccState, processedAccCtx] = (0, exports.processPlugin)(acc.config, items, accCtx);
+                        const [processedState, processedCtx] = (0, exports.processPlugin)(config, processedAccState, {
+                            ...accCtx,
+                            ...processedAccCtx,
+                        });
+                        resultCtx = { ...accCtx, ...processedAccCtx, ...processedCtx };
+                        return processedState;
+                    },
+                    () => {
+                        return { ...accCtx, ...resultCtx };
+                    },
+                ],
+            };
+            return { config: resultConfig, ctx: resultCtx };
+        }
+        else {
+            return { config, ctx: inintCtx };
+        }
+    }, { config: {}, ctx: {} });
+    return result.config;
+};
+exports.composePlugins = composePlugins;
+//# sourceMappingURL=plugins.js.map

package/lib/pubdate-plugin.d.ts

@@ -0,0 +1,9 @@
+import { publishRecord, PodliteWebPlugin } from '.';
+export interface PodliteWebPluginParams {
+    [name: string]: any;
+}
+export declare function getArticles(item: publishRecord): publishRecord[];
+export declare function getNotes(item: publishRecord): publishRecord[];
+export declare function getPages(item: publishRecord): publishRecord[];
+declare const plugin: () => PodliteWebPlugin;
+export default plugin;

package/lib/pubdate-plugin.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPages = exports.getNotes = exports.getArticles = void 0;
+const schema_1 = require("@podlite/schema");
+const node_utils_1 = require("./node-utils");
+const shared_1 = require("./shared");
+function getArticles(item) {
+    let articles = [];
+    const { file } = item;
+    const _getArticles = array => {
+        // // collect alias
+        // const aliases = array.filter(i => i.type == 'alias')
+        // at first collect all levels
+        const levels = array.filter(node => node.level && node.name === 'head') || [];
+        const nodesWithPubdate = levels.filter(node => {
+            return (0, schema_1.makeAttrs)(node, {}).exists('pubdate');
+        });
+        if (nodesWithPubdate.length > 0) {
+            for (const nodePublished of nodesWithPubdate) {
+                // get next header with same level
+                const nextHeader = levels
+                    .slice(levels.indexOf(nodePublished) + 1) // ignore this and previous nodes
+                    .filter(node => node.level <= nodePublished.level) // stop then found the same or lower level
+                    .shift();
+                let lastIndexOfArticleNode = !nextHeader ? array.length : array.indexOf(nextHeader);
+                const articleContent = array.slice(array.indexOf(nodePublished) + 1, lastIndexOfArticleNode);
+                if (articleContent.length) {
+                    const description = (0, schema_1.getFromTree)(articleContent, 'para')[0];
+                    const pubdate = (0, schema_1.makeAttrs)(nodePublished, {}).getFirstValue('pubdate');
+                    //TODO: use footer and header of document for generated articles
+                    articles.push({
+                        pubdate,
+                        title: (0, schema_1.getTextContentFromNode)(nodePublished).trim(),
+                        type: 'page',
+                        publishUrl: '',
+                        sources: [],
+                        node: (0, schema_1.mkRootBlock)({}, articleContent),
+                        description,
+                        file,
+                    });
+                }
+            }
+        }
+        array.forEach(node => {
+            if (Array.isArray(node.content)) {
+                _getArticles(node.content);
+            }
+        });
+    };
+    if (typeof item.node !== 'string') {
+        _getArticles(item.node.content);
+    }
+    return articles;
+}
+exports.getArticles = getArticles;
+function getNotes(item) {
+    const { file } = item;
+    const notes = (0, schema_1.getFromTree)(item.node, 'para')
+        .filter(n => (0, schema_1.makeAttrs)(n, {}).exists('pubdate'))
+        .map((n) => {
+        const a_pubdate = (0, schema_1.makeAttrs)(n, {}).getFirstValue('pubdate');
+        // Due to cover some cases whan new Date fail on safari, i.e.
+        // new Date("2022-05-07 10:00:00").getFullYear() -> NaN
+        // convert to ISO 8601 "2022-05-07 10:00:00" -> "2022-05-07T10:00:00"
+        const pubdate = a_pubdate.match(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}(:\d{2})?$/)
+            ? a_pubdate.replace(' ', 'T')
+            : a_pubdate;
+        //TODO: use footer and header of document for generated notes
+        return {
+            pubdate,
+            type: 'note',
+            title: null,
+            node: (0, schema_1.mkRootBlock)({}, [n]),
+            description: n,
+            file,
+            publishUrl: '',
+            sources: [],
+        };
+    });
+    return notes;
+}
+exports.getNotes = getNotes;
+function getPages(item) {
+    const { file, sources } = item;
+    const pages = (0, schema_1.getFromTree)(item.node, 'pod')
+        .filter(n => (0, schema_1.makeAttrs)(n, {}).exists('pubdate'))
+        .map((n) => {
+        const { title, description, puburl, pubdate } = (0, node_utils_1.getPublishAttributes)(n);
+        //TODO: use footer and header of document for generated pages
+        return {
+            pubdate: pubdate || '',
+            type: 'page',
+            title,
+            node: (0, schema_1.mkRootBlock)({}, [n]),
+            description,
+            file,
+            publishUrl: puburl || '',
+            sources,
+        };
+    });
+    return pages;
+}
+exports.getPages = getPages;
+const plugin = () => {
+    const outCtx = {};
+    const onExit = ctx => ({ ...ctx, ...outCtx });
+    const onProcess = (recs) => {
+        // extract articles and notes from documents
+        const rects1 = recs.reduce((acc, item) => {
+            const articles = getArticles(item);
+            const notes = getNotes(item);
+            const pages = getPages(item);
+            return [...acc, ...articles, ...notes, ...pages];
+        }, []);
+        //filter items with pubdate and sort all by pubdate
+        //@ts-ignore
+        const allItemForPublish = rects1
+            .filter(a => a.pubdate)
+            .sort((a, b) => {
+            //@ts-ignore
+            return new Date(a.pubdate) - new Date(b.pubdate);
+        });
+        // now filter  out items for publish in future
+        const isDateInFuture = dateString => {
+            return new Date().getTime() < new Date(dateString).getTime();
+        };
+        // save additional info
+        const nextPublishTime = (allItemForPublish.filter(a => isDateInFuture(a.pubdate))[0] || {}).pubdate;
+        outCtx.nextPublishTime = nextPublishTime;
+        // get not "pages" ( not have publishUrl)
+        let notPages = allItemForPublish
+            .filter(a => !a.publishUrl)
+            .filter(a => !!a.pubdate)
+            .filter(a => !isDateInFuture(a.pubdate));
+        let Pages = allItemForPublish.filter(a => a.publishUrl).filter(a => !(a.pubdate && isDateInFuture(a.pubdate)));
+        const notPagesWithPublishAttrs = (0, shared_1.addUrl)(notPages);
+        const allRecords = [...notPagesWithPublishAttrs, ...Pages];
+        return allRecords;
+    };
+    return [onProcess, onExit];
+};
+exports.default = plugin;
+//# sourceMappingURL=pubdate-plugin.js.map

package/lib/react-plugin.d.ts

@@ -0,0 +1,3 @@
+import { PodliteWebPlugin } from '.';
+declare const plugin: () => PodliteWebPlugin;
+export default plugin;

package/lib/react-plugin.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@podlite/schema");
+const constants_1 = require("./constants");
+const fs = __importStar(require("fs"));
+const node_utils_1 = require("./node-utils");
+const shared_1 = require("./shared");
+const plugin = () => {
+    const componensMap = new Map();
+    const processedNodes = new WeakSet();
+    const outCtx = {};
+    const onExit = ctx => {
+        if (!ctx.testing) {
+            // process Components
+            let componensFileContent = '';
+            for (const key of componensMap.keys()) {
+                const componentName = componensMap.get(key);
+                componensFileContent += `import ${Array.isArray(componentName) ? `{ ${componentName} }` : componentName} from "${key}"
+export { ${componentName} }
+        `;
+            }
+            componensFileContent += `
+export default {}
+`;
+            fs.writeFileSync(constants_1.COMPONENTS_LIB, componensFileContent, 'utf8');
+        }
+        return { ...ctx, ...outCtx, ...{ componensMap: Object.fromEntries(componensMap) } };
+    };
+    const processNode = (node, file) => {
+        const rules = {
+            // process JSX
+            useReact: (node, ctx, interator) => {
+                const text = (0, schema_1.getTextContentFromNode)(node);
+                const importMatchResult = text.match(/^\s*(?<component>\S+)\s*from\s*['"](?<source>\S+)['"]/);
+                if (importMatchResult) {
+                    //@ts-ignore
+                    const { component, source } = (importMatchResult || {
+                        groups: { component: undefined, source: undefined },
+                    }).groups;
+                    const { path } = source.match(/^\.?\//) ? (0, node_utils_1.getPathToOpen)(source, file) : { path: source };
+                    // save absolute Component path and Component name
+                    const notDefaultImport = component.match(/{(.*)}/);
+                    if (notDefaultImport) {
+                        const components = notDefaultImport[1].split(/\s*,\s*/);
+                        // check if already exists
+                        if (componensMap.has(path)) {
+                            const savedComponents = componensMap.get(path);
+                            const onlyUnique = (value, index, self) => self.indexOf(value) === index;
+                            const newComponents = [...savedComponents, ...components].filter(onlyUnique);
+                            componensMap.set(path, newComponents);
+                        }
+                        else {
+                            componensMap.set(path, components);
+                        }
+                    }
+                    else {
+                        componensMap.set(path, component);
+                    }
+                }
+                else {
+                    console.warn(`can't parse =React body. Expected =React Component from './somefile.tsx', but got: ${text}`);
+                }
+                return;
+            },
+            React: (node, ctx, interator) => {
+                const text = (0, schema_1.getTextContentFromNode)(node);
+                const doc = (0, shared_1.makeAstFromSrc)(text);
+                return { ...node, content: [interator(doc.content, ctx)] };
+            },
+        };
+        return (0, schema_1.makeInterator)(rules)(node, {});
+    };
+    const onProcess = (recs) => {
+        console.log('react-plugin  start');
+        const res = recs.map(item => {
+            const node = processNode(item.node, item.file);
+            // process images inside description
+            let extra = {};
+            if (item.description) {
+                extra.description = processNode(item.description, item.file);
+            }
+            if (item.template && !processedNodes.has(item.template)) {
+                const { footer, header } = item.template;
+                const processedTemplate = processNode(item.template.node, item.template.file);
+                extra.template = item.template;
+                extra.template.node = processedTemplate;
+                if (footer) {
+                    extra.template.footer = processNode(footer, item.template.file);
+                }
+                if (header) {
+                    extra.template.header = processNode(header, item.template.file);
+                }
+                processedNodes.add(item.template);
+            }
+            // process file header and footer
+            const { footer, header } = item;
+            if (footer) {
+                extra.footer = processNode(footer, item.file);
+            }
+            if (header) {
+                extra.header = processNode(header, item.file);
+            }
+            return { ...item, node, ...extra };
+        });
+        return res;
+    };
+    console.log('react-plugin  finished');
+    return [onProcess, onExit];
+};
+exports.default = plugin;
+//# sourceMappingURL=react-plugin.js.map

package/lib/shared.d.ts

@@ -0,0 +1,36 @@
+import { PodNode } from '@podlite/schema';
+import { publishRecord, pubRecord } from '.';
+export declare const getLangFromFilename: (filename?: string) => any;
+export declare const defaultLangForFile: {
+    '.rakudoc': string;
+    '.pl': string;
+    '.pm': string;
+    '.rakumod': string;
+};
+export declare const makeAstFromSrc: (src: string) => import("@podlite/schema").RootBlock;
+export declare function isExistsDocBlocks(node: PodNode): boolean;
+export declare function isExistsPubdate(node: PodNode): boolean;
+export declare function getAllArticles(array: any): Omit<pubRecord, "file">[];
+export declare const addUrl: (items: publishRecord[]) => {
+    shortUrl: string;
+    publishUrl: string;
+    sources: string[];
+    type: string;
+    pubdate: string;
+    node: import("@podlite/schema").RootBlock | (string & import("@podlite/schema").RootBlock) | (import("@podlite/schema").BlockNamed & import("@podlite/schema").RootBlock);
+    description?: PodNode;
+    file: string;
+    title: string;
+    template?: publishRecord;
+    header?: PodNode;
+    footer?: PodNode;
+    subtitle?: string;
+    pluginsData?: {
+        [name: string]: any;
+    };
+    template_file?: string;
+    number?: number;
+    sxd: string;
+    sequence?: number;
+    slug?: string;
+}[];

package/lib/shared.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addUrl = exports.getAllArticles = exports.isExistsPubdate = exports.isExistsDocBlocks = exports.makeAstFromSrc = exports.defaultLangForFile = exports.getLangFromFilename = void 0;
+const schema_1 = require("@podlite/schema");
+const podlite_1 = require("podlite");
+// now we add base60 letters
+const iso_9_1 = __importDefault(require("iso_9"));
+const newbase60_1 = __importDefault(require("newbase60"));
+const getLangFromFilename = (filename) => {
+    if (!filename)
+        return;
+    const ext = filename.split('.').pop();
+    return exports.defaultLangForFile[`.${ext}`];
+};
+exports.getLangFromFilename = getLangFromFilename;
+exports.defaultLangForFile = {
+    '.rakudoc': 'raku',
+    '.pl': 'perl',
+    '.pm': 'perl',
+    '.rakumod': 'raku',
+};
+const makeAstFromSrc = (src) => {
+    let podlite = (0, podlite_1.podlite)({ importPlugins: true }).use({});
+    let tree = podlite.parse(src);
+    const asAst = podlite.toAstResult(tree).interator;
+    return asAst;
+};
+exports.makeAstFromSrc = makeAstFromSrc;
+function isExistsDocBlocks(node) {
+    let isExistsDocBlocks = false;
+    const markAsDocBlock = (node, ctx, interator) => {
+        // skip root block
+        if (node.type === 'block' && node.name === 'root') {
+            if (node.content) {
+                return interator(node.content, ctx);
+            }
+            return;
+        }
+        isExistsDocBlocks = true;
+    };
+    const rules = {
+        ':para': markAsDocBlock,
+        ':block': markAsDocBlock,
+    };
+    (0, schema_1.makeInterator)(rules)(node, {});
+    return isExistsDocBlocks;
+}
+exports.isExistsDocBlocks = isExistsDocBlocks;
+function isExistsPubdate(node) {
+    let isShouldBePublished = false;
+    const rules = {
+        ':block': (node, ctx, interator) => {
+            const config = (0, schema_1.makeAttrs)(node, ctx);
+            if (config.exists('pubdate')) {
+                isShouldBePublished = true;
+                return;
+            }
+            if (Array.isArray(node.content)) {
+                interator(node.content);
+            }
+        },
+    };
+    const transformer = (0, schema_1.makeInterator)(rules);
+    const res = transformer(node, {});
+    return isShouldBePublished;
+}
+exports.isExistsPubdate = isExistsPubdate;
+function getAllArticles(array) {
+    let articles = [];
+    const getArticles = array => {
+        // collect alias
+        const aliases = array.filter(i => i.type == 'alias');
+        // at first collect all levels
+        const levels = array.filter(node => node.level && node.name === 'head') || [];
+        const nodesWithPubdate = levels.filter(node => {
+            return (0, schema_1.makeAttrs)(node, {}).exists('pubdate');
+        });
+        if (nodesWithPubdate.length > 0) {
+            const nodePublished = nodesWithPubdate[0];
+            // get next header with same level
+            const nextHeader = levels
+                .slice(levels.indexOf(nodePublished) + 1) // ignore this and previous nodes
+                .filter(node => node.level <= nodePublished.level) // stop then found the same or lower level
+                .shift();
+            let lastIndexOfArticleNode = !nextHeader ? array.length : array.indexOf(nextHeader);
+            const articleContent = array.slice(array.indexOf(nodePublished) + 1, lastIndexOfArticleNode);
+            if (articleContent.length) {
+                const description = (0, schema_1.getFromTree)(articleContent, 'para')[0];
+                const pubdate = (0, schema_1.makeAttrs)(nodePublished, {}).getFirstValue('pubdate');
+                articles.push({
+                    pubdate,
+                    type: 'page',
+                    node: articleContent,
+                    description,
+                });
+            }
+        }
+        array.forEach(node => {
+            if (Array.isArray(node.content)) {
+                getArticles(node.content);
+            }
+        });
+    };
+    getArticles(array);
+    return articles;
+}
+exports.getAllArticles = getAllArticles;
+const addUrl = (items) => {
+    const withSxd = items.map(i => {
+        const { file: f } = i;
+        const attrs = i;
+        const pubDate = new Date(i.pubdate);
+        const sxd = newbase60_1.default.DateToSxg(pubDate);
+        const type = i.type === 'note' ? 'n' : 'a';
+        // make short name from title
+        let words = (attrs.title || '').split(/\s/);
+        let res = [];
+        while ([...res, words[0]].join(' ').length < 120) {
+            //@ts-ignore
+            res.push(words.shift());
+        }
+        let shortTitle = res.join(' ');
+        // translit only cyrillic
+        const translit2 = /[а-яА-ЯЁё]/.test(shortTitle) ? (0, iso_9_1.default)(shortTitle, 5) : shortTitle;
+        // make url clean
+        const slug = ((translit2.replace(/`/, '') || '').replace(/\W+/g, '-') || '')
+            .replace(/(^[-]+|[-]+$)/g, '')
+            .toLowerCase();
+        return { ...attrs, type, sxd, slug, file: f };
+    });
+    // get count of each type on corresponding date
+    withSxd.reduce((acc, item) => {
+        const { sxd, type } = item;
+        acc[sxd] = acc[sxd] || {};
+        acc[sxd][type] = acc[sxd][type] || 0;
+        acc[sxd][type]++;
+        item.number = acc[sxd][type];
+        return acc;
+    }, {});
+    // sequence -  index of record at all in that day
+    withSxd.reduce((acc, item) => {
+        const { sxd } = item;
+        acc[sxd] = acc[sxd] || 0;
+        acc[sxd]++;
+        item.sequence = acc[sxd];
+        return acc;
+    }, {});
+    return withSxd.map(item => {
+        const { type, number, sxd, slug, pubdate, sequence } = item;
+        const shortUrl = `/${type}${sxd}${number}`;
+        // /2019/12/34/a1/WriteAt-my-opensource-startup-on-Perl-6-Pod
+        const date = new Date(pubdate);
+        const month = date.getMonth() + 1;
+        const year = date.getFullYear();
+        const day = date.getDate();
+        // !!!!! publishUrl may exists
+        const publishUrl = `/${year}/${month}/${day}/${sequence}/${slug}`.replace(/\/$/, '');
+        const sources = [
+            shortUrl,
+            // `/${year}/${month}/${day}/${sequence}`,
+        ];
+        return { ...item, shortUrl, publishUrl, sources };
+    });
+};
+exports.addUrl = addUrl;
+//# sourceMappingURL=shared.js.map

package/lib/site-data-plugin.d.ts

@@ -0,0 +1,25 @@
+import { PodliteWebPlugin, publishRecord } from '.';
+export interface SiteInfo {
+    redirects: {
+        source: string;
+        destination: string;
+        statusCode: number;
+    }[];
+    postsPerPage: number;
+    favicon: string;
+    url: string;
+    node: any;
+    title: string;
+    globalStyles: string;
+    footer: string;
+    gtmId: string;
+    item: publishRecord;
+}
+interface siteDataPluginInitParams {
+    public_path: string;
+    indexFilePath: string;
+    built_path: string;
+    site_url?: string;
+}
+declare const plugin: ({ public_path, indexFilePath, built_path, site_url, }: siteDataPluginInitParams) => PodliteWebPlugin;
+export default plugin;