aptechka 0.11.11 → 0.13.0

package/server-lib/optimizer/index.js

@@ -1,404 +0,0 @@
-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, getBuffer, clamp, 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 buffer = await getBuffer(source.content);
-  const response = await favicons(buffer, 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;
-  const buffer = await getBuffer(source.content);
-  return FFmpeg({
-    inputPath: settings.destinationPath,
-    outputPath: `${removeExtension(settings.destinationPath)}/frame-%04d.${settings.frameExtension || "jpg"}`,
-    fileContent: buffer,
-    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 buffer = await getBuffer(item.data);
-    const svgString = 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,
-                data: 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
-              })
-            }
-          });
-        } else 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,
-              forceJPG: 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,
-              fps: 0,
-              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;
-}
-function getNumberSetting(value, min, max) {
-  if (typeof value === "number") {
-    return clamp(value, min, max);
-  }
-  return value;
-}
-async function optimizeImage(source) {
-  const { settings } = source;
-  const content = await getBuffer(source.content);
-  const image = sharp(content);
-  const meta = await image.metadata();
-  const width = meta.width;
-  const height = meta.height;
-  const output = [];
-  const scale = getNumberSetting(settings.scale, 0, 1);
-  const quality = getNumberSetting(settings.quality, 0, 100);
-  let destinationPath = settings.destinationPath;
-  let ext = extname(destinationPath).toLowerCase();
-  if (width && height) {
-    if (scale) {
-      image.resize(Math.floor(width * scale), Math.floor(height * scale));
-    }
-  }
-  if (ext === ".jpg" || ext === ".jpeg") {
-    image.jpeg({
-      mozjpeg: true,
-      quality
-    });
-  } else if (ext === ".png") {
-    if (settings.forceJPG) {
-      const bg = typeof settings.forceJPG === "string" ? settings.forceJPG : "#ffffff";
-      image.jpeg({
-        mozjpeg: true
-      }).flatten({ background: bg });
-      destinationPath = replaceExtension(settings.destinationPath, "jpg");
-      ext = ".jpg";
-    } else {
-      image.png({
-        compressionLevel: 9,
-        adaptiveFiltering: true,
-        quality,
-        effort: 8
-      });
-    }
-  }
-  const buffer = await image.toBuffer();
-  output.push({
-    data: buffer,
-    destinationPath
-  });
-  if (settings == null ? void 0 : settings.webp) {
-    const buffer2 = await image.webp({
-      quality,
-      effort: 5
-    }).toBuffer();
-    output.push({
-      data: buffer2,
-      destinationPath: replaceExtension(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(destinationPath, `placeholder${ext}`)
-    });
-  }
-  return output;
-}
-async function optimizeVideo(source) {
-  const { settings } = source;
-  const buffer = await getBuffer(source.content);
-  const quality = getNumberSetting((settings == null ? void 0 : settings.quality) || 80, 0, 100);
-  const fps = getNumberSetting((settings == null ? void 0 : settings.fps) || 0, 0, 300);
-  const scale = getNumberSetting((settings == null ? void 0 : settings.scale) || 1, 0, 1);
-  return FFmpeg({
-    inputPath: settings.destinationPath,
-    fileContent: buffer,
-    instructions: (command) => {
-      command.addOutputOption(
-        `-crf ${Math.round((100 - quality) * 51 / 100)}`
-      );
-      if (fps) {
-        command.fps(fps);
-      }
-      command.size(`${scale * 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: await getBuffer(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

@@ -1,26 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

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

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

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

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

@@ -1,5 +0,0 @@
-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

@@ -1,51 +0,0 @@
-import { FaviconOptions } from 'favicons';
-
-export type SourceDefaultSettings = {
-    [key: string]: any;
-};
-export type SourceSetting = {
-    value: any;
-};
-export type Source<B = Buffer | File, T extends string = string, S extends SourceDefaultSettings = {}> = {
-    content: B;
-    type: T;
-    settings: S;
-};
-export type SkipSource = Source<Buffer | File, 'skip', {
-    destinationPath: string;
-}>;
-export type ImageSource = Source<Buffer | File, 'image', {
-    destinationPath: string;
-    quality?: number;
-    scale?: number;
-    placeholder?: boolean;
-    webp?: boolean;
-    forceJPG?: boolean | string;
-}>;
-export type VideoSource = Source<Buffer | File, 'video', {
-    destinationPath: string;
-    quality?: number;
-    scale?: number;
-    fps?: number;
-}>;
-export type FaviconSource = Source<Buffer | File, 'favicon', {
-    destinationPath: string;
-    destinationHtmlPath: string;
-} & FaviconOptions>;
-export type SpriteSource = Source<Array<{
-    name: string;
-    data: Buffer | File;
-}>, 'sprite', {
-    destinationPath: string;
-    name?: string;
-    removeStroke?: boolean;
-    removeFill?: boolean;
-}>;
-export type SequenceSource = Source<Buffer | File, '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/optimizer/utils.d.ts

@@ -1 +0,0 @@
-export declare function getNumberSetting<T extends number | undefined>(value: T, min: number, max: number): number | T;

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

@@ -1 +0,0 @@
-export declare function getBuffer(data: Buffer | File): Promise<Buffer>;

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

@@ -1,11 +0,0 @@
-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

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

package/server-lib/utils/index.js

@@ -1,65 +0,0 @@
-import { randomUUID } from "crypto";
-import { extname, dirname, join } from "path";
-import { mkdir, writeFile, rm, readdir, readFile } from "fs/promises";
-async function getBuffer(data) {
-  if (data instanceof Buffer) {
-    return data;
-  }
-  return Buffer.from(await data.arrayBuffer());
-}
-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;
-}
-function clamp(number, min = 0, max = 0) {
-  return Math.max(min, Math.min(number, max));
-}
-export {
-  clamp,
-  clear,
-  getBuffer,
-  getFolderFiles,
-  getTmpPath,
-  outputFile,
-  outputFiles,
-  removeExtension,
-  replaceExtension
-};

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

@@ -1 +0,0 @@
-export declare function clamp(number: number, min?: number, max?: number): number;

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

@@ -1,3 +0,0 @@
-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

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