aptechka 0.10.1 → 0.11.0

package/server-lib/optimizer/FFmpeg.d.ts

@@ -0,0 +1,10 @@
+import { default as Ffmpeg } from 'fluent-ffmpeg';
+import { Output } from '../utils';
+
+export interface FFmpegParameters {
+    inputPath: string;
+    outputPath?: string;
+    fileContent: Buffer;
+    instructions?: (command: Ffmpeg.FfmpegCommand) => void | Promise<void>;
+}
+export declare function FFmpeg({ inputPath, outputPath, fileContent, instructions, }: FFmpegParameters): Promise<Output>;

package/server-lib/optimizer/generateFavicon.d.ts

@@ -0,0 +1,4 @@
+import { FaviconSource } from './types';
+import { Output } from '../utils';
+
+export declare function generateFavicon(source: FaviconSource): Promise<Output>;

package/server-lib/optimizer/generateSequence.d.ts

@@ -0,0 +1,3 @@
+import { SequenceSource } from './types';
+
+export declare function generateSequence(source: SequenceSource): Promise<import('../utils').Output>;

package/server-lib/optimizer/generateSprite.d.ts

@@ -0,0 +1,4 @@
+import { SpriteSource } from './types';
+import { Output } from '../utils';
+
+export declare function generateSprite(source: SpriteSource): Promise<Output>;

package/server-lib/optimizer/index.d.ts

@@ -0,0 +1,10 @@
+export { FFmpeg, type FFmpegParameters } from './FFmpeg';
+export { generateFavicon } from './generateFavicon';
+export { generateSequence } from './generateSequence';
+export { generateSprite } from './generateSprite';
+export { inputFiles, type InputFilesParameters, type InputFilesSettings, type InputsFilesCallbackFaviconParameters, type InputsFilesCallbackDefaultParameters, type InputFilesCallback, type InputFilesCallbackEntry, } from './inputFiles';
+export { optimize, type OptimizeOptions, type OptimizeProgressCallback, type OptimizeProgress, } from './optimize';
+export { optimizeImage } from './optimizeImage';
+export { optimizer } from './optimizer';
+export { optimizeVideo } from './optimizeVideo';
+export { type SourceSettings, type Source, type SkipSource, type ImageSource, type VideoSource, type FaviconSource, type SpriteSource, type SequenceSource, type KnownSource, ALLOWED_IMAGE_EXTENSIONS, ALLOWED_VIDEO_EXTENSIONS, } from './types';

package/server-lib/optimizer/index.js

@@ -0,0 +1,383 @@
+import { mkdir, readFile, readdir } from "fs/promises";
+import { dirname, join, sep, extname } from "path";
+import Ffmpeg from "fluent-ffmpeg";
+import { getTmpPath, outputFile, getFolderFiles, removeExtension, clear, replaceExtension, outputFiles } from "../utils/index.js";
+import favicons from "favicons";
+import { parse } from "node-html-parser";
+import { statSync } from "fs";
+import sharp from "sharp";
+import "crypto";
+async function FFmpeg({
+  inputPath,
+  outputPath,
+  fileContent,
+  instructions
+}) {
+  return new Promise(async (resolve, reject) => {
+    const tmpInputPath = getTmpPath(inputPath);
+    const tmpOutputPath = getTmpPath(outputPath || inputPath);
+    await outputFile(tmpInputPath, fileContent);
+    await mkdir(dirname(tmpOutputPath), { recursive: true });
+    const command = Ffmpeg(tmpInputPath);
+    await (instructions == null ? void 0 : instructions(command));
+    command.on("end", async () => {
+      if (outputPath) {
+        const folderPath = dirname(tmpOutputPath);
+        const files = await getFolderFiles(folderPath);
+        const output = files.map((file) => {
+          return {
+            data: file.buffer,
+            destinationPath: join(
+              removeExtension(inputPath),
+              `${file.name.split(".").slice(0, -1)}${file.ext}`
+            )
+          };
+        });
+        await clear(tmpInputPath, folderPath);
+        resolve(output);
+      } else {
+        const file = await readFile(tmpOutputPath);
+        await clear(tmpInputPath, tmpOutputPath);
+        const output = [
+          {
+            data: file,
+            destinationPath: inputPath
+          }
+        ];
+        resolve(output);
+      }
+    }).on("error", async (e) => {
+      await clear(tmpInputPath, tmpOutputPath);
+      reject(e);
+    }).output(tmpOutputPath).run();
+  });
+}
+async function generateFavicon(source) {
+  const output = [];
+  const { settings } = source;
+  const response = await favicons(source.content, settings);
+  output.push(
+    ...[...response.images, ...response.files].map((item) => {
+      return {
+        destinationPath: join(settings.destinationPath, item.name),
+        data: item.contents
+      };
+    })
+  );
+  output.push({
+    destinationPath: settings.destinationHtmlPath,
+    data: response.html.join("\n")
+  });
+  return output;
+}
+async function generateSequence(source) {
+  const { settings } = source;
+  return FFmpeg({
+    inputPath: settings.destinationPath,
+    outputPath: `${removeExtension(settings.destinationPath)}/frame-%04d.${settings.frameExtension || "jpg"}`,
+    fileContent: source.content,
+    instructions: (command) => {
+      if (settings.fps) {
+        command.addOutputOption([`-r ${Math.max(1, settings.fps | 0)}`]);
+      }
+    }
+  });
+}
+async function generateSprite(source) {
+  const output = [];
+  const { settings } = source;
+  const spriteName = source.settings.name || "sprite";
+  const svgOpenTag = `<svg id="${spriteName}" xmlns="http://www.w3.org/2000/svg">`;
+  const svgCloseTag = "</svg>";
+  let spriteString = svgOpenTag;
+  for await (const item of source.content) {
+    const svgString = item.buffer.toString();
+    const root = parse(svgString);
+    const icon = root.querySelector("svg");
+    icon.removeAttribute("width");
+    icon.removeAttribute("height");
+    if (settings.removeFill) {
+      icon.querySelectorAll("*").forEach((child) => {
+        child.removeAttribute("fill");
+      });
+    }
+    if (settings.removeStroke) {
+      icon.querySelectorAll("*").forEach((child) => {
+        child.removeAttribute("stroke");
+      });
+    }
+    const symbolOpenTag = `<symbol id="${`${spriteName}:${item.name}`}" viewBox="${icon.getAttribute(
+      "viewBox"
+    )}">`;
+    const symbolContent = icon.innerHTML;
+    const symbolCloseTag = `</symbol>`;
+    const symbol = symbolOpenTag + symbolContent + symbolCloseTag;
+    spriteString += symbol;
+  }
+  spriteString += svgCloseTag;
+  output.push({
+    data: spriteString,
+    destinationPath: source.settings.destinationPath
+  });
+  return output;
+}
+const ALLOWED_IMAGE_EXTENSIONS = ["jpg", "png", "webp", "jpeg"];
+const ALLOWED_VIDEO_EXTENSIONS = ["mp4", "mov"];
+function specialPath(path, specialString) {
+  const splitted = path.split("/");
+  const left = splitted.slice(0, -1).join("/");
+  const leaf = splitted.slice(-1).join("");
+  const ext = extname(leaf);
+  const sourceName = leaf.replace(ext, "");
+  const name = sourceName.replace(specialString, "");
+  if (name) {
+    if (name.startsWith("-")) {
+      return `${left}/${name.slice(1)}${ext}`;
+    } else {
+      return `${left}/${name}${ext}`;
+    }
+  } else {
+    return `${left}/${sourceName.replace("@", "")}${ext}`;
+  }
+}
+async function inputFiles({
+  sourceFolder,
+  destinationFolder,
+  settings
+}) {
+  var _a, _b, _c, _d, _e;
+  let sources = [];
+  const currentPaths = await readdir(sourceFolder);
+  for await (const currentPath of currentPaths) {
+    if (!currentPath.includes(".DS_Store")) {
+      const sourcePath = join(sourceFolder, currentPath.toString());
+      const destinationPath = join(
+        destinationFolder,
+        sourcePath.replaceAll(sep, "/").replace(sourceFolder, "")
+      );
+      if (statSync(sourcePath).isDirectory()) {
+        if (sourcePath.includes("@sprite")) {
+          const files = await getFolderFiles(sourcePath);
+          const content = [];
+          files.forEach((file) => {
+            if (file.ext === ".svg") {
+              content.push({
+                name: file.name,
+                buffer: file.buffer
+              });
+            }
+          });
+          const destinationSvgPath = specialPath(
+            `${destinationPath}.svg`,
+            "@sprite"
+          );
+          sources.push({
+            type: "sprite",
+            content,
+            settings: {
+              destinationPath: destinationSvgPath,
+              ...(_a = settings == null ? void 0 : settings.sprite) == null ? void 0 : _a.call(settings, {
+                destinationPath: destinationSvgPath
+              })
+            }
+          });
+        } else {
+          const result = await inputFiles({
+            sourceFolder: sourcePath,
+            destinationFolder: destinationPath,
+            settings
+          });
+          sources = [...sources, ...result];
+        }
+      } else {
+        const ext = extname(destinationPath).toLowerCase().slice(1);
+        const content = await readFile(sourcePath);
+        if (destinationPath.includes("@favicon")) {
+          const destinationFolderPath = specialPath(
+            removeExtension(destinationPath),
+            "@favicon"
+          );
+          const destinationHtmlPath = `${destinationFolderPath}/head.html`;
+          sources.push({
+            content,
+            type: "favicon",
+            settings: {
+              destinationPath: destinationFolderPath,
+              destinationHtmlPath,
+              ...(_b = settings == null ? void 0 : settings.favicon) == null ? void 0 : _b.call(settings, {
+                destinationPath: destinationFolderPath,
+                destinationHtmlPath
+              })
+            }
+          });
+        }
+        if (destinationPath.includes("@sequence")) {
+          const path = specialPath(destinationPath, "@sequence");
+          sources.push({
+            content,
+            type: "sequence",
+            settings: {
+              destinationPath: path,
+              ...(_c = settings == null ? void 0 : settings.sequence) == null ? void 0 : _c.call(settings, { destinationPath: path })
+            }
+          });
+        } else if (ALLOWED_IMAGE_EXTENSIONS.includes(
+          ext
+        )) {
+          sources.push({
+            content,
+            type: "image",
+            settings: {
+              placeholder: false,
+              quality: 80,
+              scale: 1,
+              webp: false,
+              destinationPath,
+              ...(_d = settings == null ? void 0 : settings.image) == null ? void 0 : _d.call(settings, { destinationPath })
+            }
+          });
+        } else if (ALLOWED_VIDEO_EXTENSIONS.includes(
+          ext
+        )) {
+          sources.push({
+            content,
+            type: "video",
+            settings: {
+              quality: 80,
+              scale: 1,
+              destinationPath,
+              ...(_e = settings == null ? void 0 : settings.video) == null ? void 0 : _e.call(settings, { destinationPath })
+            }
+          });
+        } else {
+          sources.push({
+            content,
+            type: "skip",
+            settings: { destinationPath }
+          });
+        }
+      }
+    }
+  }
+  return sources;
+}
+async function optimizeImage(source) {
+  const { settings } = source;
+  const ext = extname(settings.destinationPath).toLowerCase();
+  const image = sharp(source.content);
+  const meta = await image.metadata();
+  const width = meta.width;
+  const height = meta.height;
+  const output = [];
+  if (width && height) {
+    if (settings == null ? void 0 : settings.scale) {
+      image.resize(
+        Math.floor(width * settings.scale),
+        Math.floor(height * settings.scale)
+      );
+    }
+  }
+  if (ext === ".jpg" || ext === ".jpeg") {
+    image.jpeg({
+      mozjpeg: true,
+      quality: settings == null ? void 0 : settings.quality
+    });
+  } else if (ext === ".png") {
+    image.png({
+      compressionLevel: 9,
+      adaptiveFiltering: true,
+      quality: settings == null ? void 0 : settings.quality,
+      effort: 8
+    });
+  }
+  const buffer = await image.toBuffer();
+  output.push({
+    data: buffer,
+    destinationPath: settings.destinationPath
+  });
+  if (settings == null ? void 0 : settings.webp) {
+    const buffer2 = await image.webp({
+      quality: settings.quality,
+      effort: 5
+    }).toBuffer();
+    output.push({
+      data: buffer2,
+      destinationPath: replaceExtension(settings.destinationPath, "webp")
+    });
+  }
+  if (settings == null ? void 0 : settings.placeholder) {
+    const buffer2 = await image.resize(20, 20).blur(10).toBuffer();
+    output.push({
+      data: buffer2,
+      destinationPath: replaceExtension(
+        settings.destinationPath,
+        `placeholder${ext}`
+      )
+    });
+  }
+  return output;
+}
+async function optimizeVideo(source) {
+  const { settings } = source;
+  return FFmpeg({
+    inputPath: settings.destinationPath,
+    fileContent: source.content,
+    instructions: (command) => {
+      command.addOutputOption(
+        `-crf ${Math.round((100 - ((settings == null ? void 0 : settings.quality) || 80)) * 51 / 100)}`
+      );
+      if (settings == null ? void 0 : settings.fps) {
+        command.fps(settings.fps);
+      }
+      command.size(`${((settings == null ? void 0 : settings.scale) || 1) * 100}%`);
+    }
+  });
+}
+async function optimize(sources, options) {
+  var _a;
+  const output = [];
+  let ready = 0;
+  for await (const source of sources) {
+    if (source.type === "image") {
+      output.push(...await optimizeImage(source));
+    } else if (source.type === "video") {
+      output.push(...await optimizeVideo(source));
+    } else if (source.type === "favicon") {
+      output.push(...await generateFavicon(source));
+    } else if (source.type === "sprite") {
+      output.push(...await generateSprite(source));
+    } else if (source.type === "sequence") {
+      output.push(...await generateSequence(source));
+    } else {
+      output.push({
+        data: source.content,
+        destinationPath: source.settings.destinationPath
+      });
+    }
+    (_a = options == null ? void 0 : options.onProgress) == null ? void 0 : _a.call(options, {
+      ready: ++ready,
+      total: sources.length,
+      path: source.settings.destinationPath
+    });
+  }
+  return output;
+}
+async function optimizer(parameters) {
+  await clear(parameters.destinationFolder);
+  const input = await inputFiles(parameters);
+  const optimized = await optimize(input, parameters);
+  await outputFiles(optimized);
+}
+export {
+  ALLOWED_IMAGE_EXTENSIONS,
+  ALLOWED_VIDEO_EXTENSIONS,
+  FFmpeg,
+  generateFavicon,
+  generateSequence,
+  generateSprite,
+  inputFiles,
+  optimize,
+  optimizeImage,
+  optimizeVideo,
+  optimizer
+};

package/server-lib/optimizer/inputFiles.d.ts

@@ -0,0 +1,26 @@
+import { FaviconSource, ImageSource, KnownSource, SequenceSource, Source, SpriteSource, VideoSource } from './types';
+
+export interface InputFilesCallbackEntry {
+    type: KnownSource['type'];
+    path: string;
+}
+export type InputFilesCallback<T extends Source> = (entry: InputFilesCallbackEntry) => T;
+export interface InputsFilesCallbackDefaultParameters {
+    destinationPath: string;
+}
+export interface InputsFilesCallbackFaviconParameters extends InputsFilesCallbackDefaultParameters {
+    destinationHtmlPath: string;
+}
+export interface InputFilesSettings {
+    image?(parameters: InputsFilesCallbackDefaultParameters): Partial<ImageSource['settings']>;
+    video?(parameters: InputsFilesCallbackDefaultParameters): Partial<VideoSource['settings']>;
+    favicon?(parameters: InputsFilesCallbackFaviconParameters): Partial<FaviconSource['settings']>;
+    sprite?(parameters: InputsFilesCallbackDefaultParameters): Partial<SpriteSource['settings']>;
+    sequence?(parameters: InputsFilesCallbackDefaultParameters): Partial<SequenceSource['settings']>;
+}
+export interface InputFilesParameters {
+    sourceFolder: string;
+    destinationFolder: string;
+    settings?: InputFilesSettings;
+}
+export declare function inputFiles({ sourceFolder, destinationFolder, settings, }: InputFilesParameters): Promise<KnownSource[]>;

package/server-lib/optimizer/optimize.d.ts

@@ -0,0 +1,13 @@
+import { Output } from '../utils';
+import { KnownSource } from './types';
+
+export interface OptimizeProgress {
+    ready: number;
+    total: number;
+    path: string;
+}
+export type OptimizeProgressCallback = (progress: OptimizeProgress) => void;
+export interface OptimizeOptions {
+    onProgress?: OptimizeProgressCallback;
+}
+export declare function optimize(sources: Array<KnownSource>, options?: OptimizeOptions): Promise<Output>;

package/server-lib/optimizer/optimizeImage.d.ts

@@ -0,0 +1,4 @@
+import { ImageSource } from './types';
+import { Output } from '../utils';
+
+export declare function optimizeImage(source: ImageSource): Promise<Output>;

package/server-lib/optimizer/optimizeVideo.d.ts

@@ -0,0 +1,3 @@
+import { VideoSource } from './types';
+
+export declare function optimizeVideo(source: VideoSource): Promise<import('../utils').Output>;

package/server-lib/optimizer/optimizer.d.ts

@@ -0,0 +1,5 @@
+import { InputFilesParameters } from './inputFiles';
+import { OptimizeOptions } from './optimize';
+
+export type OptimizerParameters = InputFilesParameters & OptimizeOptions;
+export declare function optimizer(parameters: OptimizerParameters): Promise<void>;

package/server-lib/optimizer/types.d.ts

@@ -0,0 +1,47 @@
+import { FaviconOptions } from 'favicons';
+
+export type SourceSettings = {
+    [key: string]: any;
+};
+export interface Source<B = Buffer, T extends string = string, S extends SourceSettings = {}> {
+    content: B;
+    type: T;
+    settings: S;
+}
+export type SkipSource = Source<Buffer, 'skip', {
+    destinationPath: string;
+}>;
+export type ImageSource = Source<Buffer, 'image', {
+    destinationPath: string;
+    quality?: number;
+    scale?: number;
+    placeholder?: boolean;
+    webp?: boolean;
+}>;
+export type VideoSource = Source<Buffer, 'video', {
+    destinationPath: string;
+    quality?: number;
+    scale?: number;
+    fps?: number;
+}>;
+export type FaviconSource = Source<Buffer, 'favicon', {
+    destinationPath: string;
+    destinationHtmlPath: string;
+} & FaviconOptions>;
+export type SpriteSource = Source<Array<{
+    name: string;
+    buffer: Buffer;
+}>, 'sprite', {
+    destinationPath: string;
+    name?: string;
+    removeStroke?: boolean;
+    removeFill?: boolean;
+}>;
+export type SequenceSource = Source<Buffer, 'sequence', {
+    destinationPath: string;
+    fps?: number;
+    frameExtension?: 'png' | 'jpg';
+}>;
+export type KnownSource = VideoSource | ImageSource | SkipSource | FaviconSource | SpriteSource | SequenceSource;
+export declare const ALLOWED_IMAGE_EXTENSIONS: readonly ["jpg", "png", "webp", "jpeg"];
+export declare const ALLOWED_VIDEO_EXTENSIONS: readonly ["mp4", "mov"];

package/server-lib/utils/fs.d.ts

@@ -0,0 +1,11 @@
+import { Output, WriteFileData } from './types';
+
+export declare function outputFile(path: string, data: WriteFileData): Promise<void>;
+export declare function outputFiles(output: Output): Promise<void>;
+export declare function clear(...paths: Array<string>): Promise<void[]>;
+export declare function getFolderFiles(folderPath: string): Promise<{
+    name: string;
+    path: string;
+    ext: string;
+    buffer: Buffer;
+}[]>;

package/server-lib/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { removeExtension, replaceExtension, getTmpPath } from './path';
+export { outputFile, outputFiles, clear, getFolderFiles } from './fs';
+export type { WriteFileData, OutputItem, Output } from './types';

package/server-lib/utils/index.js

@@ -0,0 +1,54 @@
+import { randomUUID } from "crypto";
+import { extname, dirname, join } from "path";
+import { mkdir, writeFile, rm, readdir, readFile } from "fs/promises";
+function removeExtension(path) {
+  return path.replace(/\.[^/.]+$/, "");
+}
+function replaceExtension(path, newExtension) {
+  return `${removeExtension(path)}.${newExtension}`;
+}
+function getTmpPath(path) {
+  const random = randomUUID();
+  return `${removeExtension(path)}.${random}${extname(path)}`;
+}
+async function outputFile(path, data) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, data);
+}
+async function outputFiles(output) {
+  for await (const item of output) {
+    await mkdir(dirname(item.destinationPath), { recursive: true });
+    await writeFile(item.destinationPath, item.data);
+    outputFile(item.destinationPath, item.data);
+  }
+}
+async function clear(...paths) {
+  return Promise.all(
+    paths.map((p) => {
+      return rm(p, { force: true, recursive: true });
+    })
+  );
+}
+async function getFolderFiles(folderPath) {
+  const leafs = await readdir(folderPath);
+  const files = [];
+  for await (const leaf of leafs) {
+    const buffer = await readFile(join(folderPath, leaf));
+    files.push({
+      name: removeExtension(leaf),
+      path: join(folderPath, leaf),
+      ext: extname(leaf),
+      buffer
+    });
+  }
+  return files;
+}
+export {
+  clear,
+  getFolderFiles,
+  getTmpPath,
+  outputFile,
+  outputFiles,
+  removeExtension,
+  replaceExtension
+};

package/server-lib/utils/path.d.ts

@@ -0,0 +1,3 @@
+export declare function removeExtension(path: string): string;
+export declare function replaceExtension(path: string, newExtension: string): string;
+export declare function getTmpPath(path: string): string;

package/server-lib/utils/types.d.ts

@@ -0,0 +1,8 @@
+import { writeFile } from 'fs/promises';
+
+export type WriteFileData = Parameters<typeof writeFile>['1'];
+export interface OutputItem {
+    data: WriteFileData;
+    destinationPath: string;
+}
+export type Output = Array<OutputItem>;