@redneckz/wildless-cms-uni-blocks 0.14.831 → 0.14.832

package/src/content-page-repository/resizeImg.ts

@@ -1,17 +0,0 @@
-import sharp, { type ResizeOptions, type Sharp } from 'sharp';
-import { type ImageSize } from '../model/ImageSize';
-
-export const resizeImg =
-  (size?: Partial<ImageSize>, options?: ResizeOptions) =>
-  (chain: Sharp): Sharp =>
-    size
-      ? chain.resize(size.width || null, size.height || null, {
-          /*
-           * Editor behaviour with one dimension present: resize by given dimension maintaining aspect ratio. (fit: contain)
-           * With two dimensions present: resize trying to fill given dimensions (fit: fill)
-           */
-          fit: size.width && size.height ? sharp.fit.fill : sharp.fit.contain,
-          background: { r: 0, g: 0, b: 0, alpha: 0 },
-          ...options,
-        })
-      : chain;

package/src/content-page-repository/transformAttachmentLink.ts

@@ -1,46 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import util from 'util';
-import { type LinkProps } from '../model/LinkProps';
-import { isUUID } from '../utils/isUUID';
-import { clearAttachmentHref } from './clearAttachmentHref';
-import { type TransformationOptions } from './TransformationOptions';
-
-const mkdir = util.promisify(fs.mkdir);
-const copyFile = util.promisify(fs.copyFile);
-
-export async function transformAttachmentLink(
-  link: LinkProps,
-  pagePath: string,
-  options: TransformationOptions,
-): Promise<LinkProps> {
-  if (!link?.href) {
-    return link;
-  }
-
-  try {
-    return {
-      ...link,
-      href: await transformHref(clearAttachmentHref(link.href), options),
-    };
-  } catch (e) {
-    console.info(`No "${link.href}" attachment found on page: "${pagePath}"`);
-
-    return link;
-  }
-}
-
-async function transformHref(input: string, options: TransformationOptions) {
-  if (isUUID(input)) {
-    return input;
-  }
-
-  const { contentDir, publicDir } = options;
-  const docRelativePath = path.relative(contentDir, input);
-  const output = path.join(publicDir, docRelativePath);
-
-  await mkdir(path.dirname(output), { recursive: true });
-  await copyFile(input, output);
-
-  return path.join('/', docRelativePath);
-}

package/src/content-page-repository/transformContentPage.ts

@@ -1,102 +0,0 @@
-import { type JSONRecord } from '@redneckz/json-op';
-import fs from 'fs';
-import util from 'util';
-import { type Attachment } from '../model/Attachment';
-import { type ContentPageDef } from '../model/ContentPageDef';
-import { type LinkProps } from '../model/LinkProps';
-import { type Picture } from '../model/Picture';
-import { isUUID } from '../utils/isUUID';
-import { tableFunc } from '../utils/tableFunc';
-import { ATTACHMENT_PREFIX } from './clearAttachmentHref';
-import { DOCUMENT_EXT_LIST, IMAGE_EXT_LIST, OUTPUT_SUFFIX } from './extensions';
-import { mapJSON } from './mapJSON';
-import { mergePages } from './mergePages';
-import { type TransformationOptions } from './TransformationOptions';
-import { transformAttachmentLink } from './transformAttachmentLink';
-import { transformDocument } from './transformDocument';
-import { transformHTML } from './transformHTML';
-import { transformMarkdown } from './transformMarkdown';
-import { transformPicture } from './transformPicture';
-
-const readFile = util.promisify(fs.readFile);
-const writeFile = util.promisify(fs.writeFile);
-
-const DEFAULT_PARENT_CONTENT = {};
-
-export async function transformContentPage(
-  pagePath: string,
-  options: TransformationOptions,
-): Promise<ContentPageDef> {
-  const content: JSONRecord = JSON.parse(await readFile(pagePath, 'utf8'));
-  const parentContent: JSONRecord = await (content?._extends
-    ? JSON.parse(await readFile(content._extends as string, 'utf-8'))
-    : DEFAULT_PARENT_CONTENT);
-
-  const mergedContent = mergePages(parentContent, content);
-
-  const result = await mapJSON(mergedContent as ContentPageDef, async (value: any, [key]) => {
-    try {
-      return await transform([value, key])(value, pagePath, options);
-    } catch (ex) {
-      console.warn(`Error while transforming field "${key}" on page: ${pagePath}`);
-      console.error(ex);
-    }
-
-    return value;
-  });
-
-  await writeFile(generatedPagePath(pagePath), JSON.stringify(result), 'utf-8');
-
-  return result;
-}
-
-const transform = tableFunc<
-  [any, string],
-  (value: any, pagePath: string, options: TransformationOptions) => Promise<any>
->([
-  [([value, key]) => isMarkdown(key, value), async (value: string) => transformMarkdown(value)],
-  [([value, key]) => isHTML(key, value), async (value: string) => transformHTML(value)],
-  [([value]) => isUUID(value?.src as string), async (value) => ({ src: value?.src })],
-  [
-    ([value]) => isAttachmentLink(value),
-    async (value, pagePath, options) =>
-      transformAttachmentLink(value as LinkProps, pagePath, options),
-  ],
-  [
-    ([value]) => isAttachmentFile(value, DOCUMENT_EXT_LIST),
-    async (value, pagePath, options) => transformDocument(value as Attachment, pagePath, options),
-  ],
-  [
-    ([value]) => isAttachmentFile(value, IMAGE_EXT_LIST),
-    async (value, pagePath, options) => transformPicture(value as Picture, pagePath, options),
-  ],
-  [() => true, async (value) => value],
-]);
-
-export const generatedPagePath = (pagePath: string) => `${pagePath}${OUTPUT_SUFFIX}`;
-
-const isMarkdown = (key: string, value: any): value is string =>
-  isString(value) && key?.endsWith('__md');
-const isHTML = (key: string, value: any): value is string =>
-  isString(value) && key?.endsWith('__html');
-
-const isAttachmentLink = (_: any): _ is LinkProps =>
-  isLocalPath(_?.href) && (_.href.startsWith(ATTACHMENT_PREFIX) || isLocalFile(_.href));
-
-const isAttachmentFile = (_: any, exts: string[]): _ is Attachment =>
-  Boolean(_ && isLocalPath(_?.src)) && exts.some((ext) => _.src.toLowerCase().endsWith(ext));
-
-const isLocalPath = (_: any): _ is string => isString(_) && _.length < 1024 && !isURL(_);
-const isURL = (src: string) => ['data:', 'https:', 'http:'].some((proto) => src.startsWith(proto));
-
-const isString = (_: any): _ is string => Boolean(_ && typeof _ === 'string');
-
-const isLocalFile = (_: any): _ is string => isString(_) && isFileExists(_);
-
-const isFileExists = (_: string) => {
-  try {
-    return fs.statSync(_).isFile();
-  } catch (ex) {
-    return false;
-  }
-};

package/src/content-page-repository/transformDocument.ts

@@ -1,43 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import util from 'util';
-import { type Attachment } from '../model/Attachment';
-import { isUUID } from '../utils/isUUID';
-import { type TransformationOptions } from './TransformationOptions';
-
-const mkdir = util.promisify(fs.mkdir);
-const copyFile = util.promisify(fs.copyFile);
-const stat = util.promisify(fs.stat);
-
-export async function transformDocument(
-  attachment: Attachment,
-  pagePath: string,
-  options: TransformationOptions,
-): Promise<Attachment> {
-  if (!attachment?.src || isUUID(attachment.src)) {
-    return attachment;
-  }
-
-  const { contentDir, publicDir } = options;
-  const input = attachment.src;
-  const docRelativePath = path.relative(contentDir, input);
-  const output = path.join(publicDir, docRelativePath);
-  const inputFileSize = (await stat(input)).size;
-
-  try {
-    await mkdir(path.dirname(output), { recursive: true });
-    await copyFile(input, output);
-  } catch (e) {
-    console.info(`No "${input}" attachment found on page: "${pagePath}"`);
-
-    return attachment;
-  }
-
-  const src = path.join('/', docRelativePath);
-
-  return {
-    ...attachment,
-    src,
-    fileSize: inputFileSize,
-  };
-}

package/src/content-page-repository/transformHTML.ts

@@ -1,28 +0,0 @@
-import rehypeParse from 'rehype-parse';
-import rehypeSanitize, { defaultSchema } from 'rehype-sanitize';
-import rehypeStringify from 'rehype-stringify';
-import { unified } from 'unified';
-import { replaceHeadingTags } from './replaceHeadingTags';
-
-export async function transformHTML(html: string | null | undefined): Promise<string> {
-  if (!html) {
-    return '';
-  }
-
-  const extendedSchema = {
-    ...defaultSchema,
-    protocols: {
-      ...defaultSchema.protocols,
-      href: [...(defaultSchema?.protocols?.href || []), 'tel'],
-      src: [...(defaultSchema.protocols?.src ?? []), 'data'],
-    },
-  };
-
-  const result = await unified()
-    .use(rehypeParse)
-    .use(rehypeSanitize, extendedSchema)
-    .use(rehypeStringify)
-    .process(html);
-
-  return replaceHeadingTags(result.toString('utf-8'));
-}

package/src/content-page-repository/transformImg.ts

@@ -1,81 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import sharp, { type Sharp } from 'sharp';
-import util from 'util';
-import { type ImageSize } from '../model/ImageSize';
-import { type ImgSource } from '../model/Picture';
-import { isPictureSizeEmpty } from '../utils/isPictureSizeEmpty';
-import { computeImgOutputPath } from './computeImgOutputPath';
-import { resizeImg } from './resizeImg';
-import { type TransformationOptions } from './TransformationOptions';
-
-const mkdir = util.promisify(fs.mkdir);
-const copyFile = util.promisify(fs.copyFile);
-
-type ImgOutputPath = string;
-type TransformationTaskKey = ImgOutputPath;
-type TransformationTasksCache = Map<TransformationTaskKey, Promise<ImgOutputPath>>;
-
-type TransformImgOptions = TransformationOptions &
-  ImgSource & { containerSize?: ImageSize; cache?: TransformationTasksCache };
-
-const defaultTransformationCache: TransformationTasksCache = new Map();
-
-const isNilTransform = ({ size, containerSize, format }: TransformImgOptions) =>
-  isPictureSizeEmpty(size) && isPictureSizeEmpty(containerSize) && !format;
-
-const isVectorInput = (input: string) =>
-  ['.svg', '.eps', '.epsf', '.epsi', '.pdf'].some((ext) => input.toLowerCase().endsWith(ext));
-
-export function transformImg(
-  src: string,
-  pagePath: string,
-  options: TransformImgOptions,
-): ImgOutputPath | Promise<ImgOutputPath> {
-  if (!src) {
-    return src;
-  }
-
-  const withoutTransform = isNilTransform(options) || isVectorInput(src);
-
-  const output = computeImgOutputPath(src, options, withoutTransform);
-
-  const { cache = defaultTransformationCache } = options;
-
-  const cachedResult = cache.get(output);
-  if (cachedResult) {
-    return cachedResult;
-  }
-
-  const result = (async () => {
-    try {
-      await mkdir(path.dirname(output), { recursive: true });
-      if (withoutTransform) {
-        await copyFile(src, output);
-      } else {
-        const chain = await computeTransformationChain(options)(sharp(src));
-        await chain.toFile(output);
-      }
-    } catch (e) {
-      console.info(`No "${src}" attachment found on page: "${pagePath}"`);
-    }
-
-    return output;
-  })();
-  cache.set(output, result);
-
-  return result;
-}
-
-const computeTransformationChain = ({
-  size,
-  containerSize,
-  format,
-  options,
-}: TransformImgOptions) =>
-  pipe(resizeImg(isPictureSizeEmpty(size) ? containerSize : size), (_) =>
-    format ? _.toFormat(format, { ...options, lossless: true }) : _,
-  );
-
-const pipe = (...operations: Array<(chain: Sharp) => Promise<Sharp> | Sharp>) =>
-  operations.reduce((a, b) => async (chain: Sharp) => b(await a(chain)));

package/src/content-page-repository/transformMarkdown.ts

@@ -1,14 +0,0 @@
-import remarkHtml from 'remark-html';
-import remarkParse from 'remark-parse';
-import { unified } from 'unified';
-import { replaceHeadingTags } from './replaceHeadingTags';
-
-export async function transformMarkdown(markdown: string | null | undefined): Promise<string> {
-  if (!markdown) {
-    return '';
-  }
-
-  const result = await unified().use(remarkParse).use(remarkHtml).process(markdown);
-
-  return replaceHeadingTags(result.toString('utf-8'));
-}

package/src/content-page-repository/transformPicture.ts

@@ -1,35 +0,0 @@
-import path from 'path';
-import sharp from 'sharp';
-import { type Picture } from '../model/Picture';
-import { type TransformationOptions } from './TransformationOptions';
-import { transformImg } from './transformImg';
-
-export async function transformPicture(
-  picture: Picture,
-  pagePath: string,
-  options: TransformationOptions,
-): Promise<Picture> {
-  const src = picture?.src || '';
-
-  const transformedImgPath = await transformImg(src, pagePath, { ...options, ...picture });
-
-  const { width, height } = await sharp(transformedImgPath).metadata();
-  const containerSize = width && height ? { width, height } : undefined;
-
-  const sources = picture.sources || [];
-  const transformedSources = await Promise.all(
-    sources.map((_) => transformImg(src, pagePath, { ...options, ..._, containerSize })),
-  );
-
-  const imgPathToSrc = (_: string) => path.join('/', path.relative(options.publicDir, _));
-
-  return {
-    ...picture,
-    src: imgPathToSrc(transformedImgPath),
-    sources: transformedSources.map((_, i) => ({
-      ...sources[i],
-      src: imgPathToSrc(_),
-      size: { width, height },
-    })),
-  };
-}