cabloy 5.1.95 → 5.1.97

package/vona/src/suite-vendor/a-image/modules/image-native/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "vona-module-image-native",
+  "version": "5.0.1",
+  "description": "",
+  "keywords": [
+    "Vona Module"
+  ],
+  "author": "",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "import": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && node ../../../../../packages-cli/cli/src/bin/vona.ts :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run tsc:publish",
+    "prepack": "clean-package",
+    "postpack": "clean-package restore"
+  },
+  "dependencies": {
+    "sharp": "^0.35.2"
+  },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.1.3"
+  },
+  "clean-package": {
+    "indent": 2,
+    "remove": [
+      "clean-package",
+      "exports.\\..import"
+    ]
+  },
+  "title": "image-native",
+  "vonaModule": {
+    "dependencies": {
+      "a-image": "5.0.0"
+    },
+    "globalDependencies": {
+      "sharp": true
+    },
+    "bundle": {
+      "externals": [
+        "sharp"
+      ]
+    },
+    "capabilities": {
+      "monkey": true
+    }
+  }
+}

package/vona/src/suite-vendor/a-image/modules/image-native/src/.metadata/index.ts

@@ -0,0 +1,114 @@
+// eslint-disable
+/** service: begin */
+export * from '../service/imageNative.ts';
+
+import 'vona-module-a-bean';
+declare module 'vona-module-a-bean' {
+  
+    export interface IServiceRecord {
+      'image-native:imageNative': never;
+    }
+
+  
+}
+declare module 'vona-module-image-native' {
+  
+        export interface ServiceImageNative {
+          /** @internal */
+          get scope(): ScopeModuleImageNative;
+        }
+
+          export interface ServiceImageNative {
+            get $beanFullName(): 'image-native.service.imageNative';
+            get $onionName(): 'image-native:imageNative';
+            
+          } 
+}
+/** service: end */
+/** service: begin */
+import type { ServiceImageNative } from '../service/imageNative.ts';
+export interface IModuleService {
+  'imageNative': ServiceImageNative;
+}
+/** service: end */
+/** service: begin */
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    'image-native.service.imageNative': ServiceImageNative;
+  }
+}
+/** service: end */
+/** imageProvider: begin */
+export * from '../bean/imageProvider.native.ts';
+import type { IImageProviderOptionsNative } from '../bean/imageProvider.native.ts';
+import 'vona-module-a-image';
+declare module 'vona-module-a-image' {
+  
+    export interface IImageProviderRecord {
+      'image-native:native': IImageProviderOptionsNative;
+    }
+
+  
+}
+declare module 'vona-module-image-native' {
+  
+        export interface ImageProviderNative {
+          /** @internal */
+          get scope(): ScopeModuleImageNative;
+        }
+
+          export interface ImageProviderNative {
+            get $beanFullName(): 'image-native.imageProvider.native';
+            get $onionName(): 'image-native:native';
+            get $onionOptions(): IImageProviderOptionsNative;
+          } 
+}
+/** imageProvider: end */
+/** imageProvider: begin */
+import type { ImageProviderNative } from '../bean/imageProvider.native.ts';
+export interface IModuleImageProvider {
+  'native': ImageProviderNative;
+}
+/** imageProvider: end */
+/** config: begin */
+export * from '../config/config.ts';
+import type { config } from '../config/config.ts';
+/** config: end */
+/** monkey: begin */
+export * from '../monkey.ts';
+/** monkey: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleConfig } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+
+@Scope()
+export class ScopeModuleImageNative extends BeanScopeBase {}
+
+export interface ScopeModuleImageNative {
+  util: BeanScopeUtil;
+config: TypeModuleConfig<typeof config>;
+service: IModuleService;
+imageProvider: IModuleImageProvider;
+}
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanScopeRecord {
+    'image-native': ScopeModuleImageNative;
+  }
+
+  export interface IBeanScopeContainer {
+    imageNative: ScopeModuleImageNative;
+  }
+  
+  export interface IBeanScopeConfig {
+    'image-native': ReturnType<typeof config>;
+  }
+
+  
+
+  
+}
+/** scope: end */

package/vona/src/suite-vendor/a-image/modules/image-native/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'image-native';
+export { ScopeModuleImageNative as ScopeModule } from './index.ts';

package/vona/src/suite-vendor/a-image/modules/image-native/src/bean/imageProvider.native.ts

@@ -0,0 +1,131 @@
+import type {
+  IDecoratorImageProviderOptions,
+  IImageDeliveryOptions,
+  IImageDownloadResult,
+  IImageProviderClientOptions,
+  IImageProviderClientRecord,
+  IImageProviderExecute,
+  IImageProviderResource,
+  IImageUploadInput,
+  IImageVariantRequest,
+} from 'vona-module-a-image';
+import type { EntityImage } from 'vona-module-a-image';
+
+import fse from 'fs-extra';
+import { BeanBase } from 'vona';
+import { ImageProvider } from 'vona-module-a-image';
+
+export interface IImageProviderNativeClientRecord extends IImageProviderClientRecord {}
+
+export interface IImageProviderNativeClientOptions extends IImageProviderClientOptions {
+  subdir?: string;
+  signingKey?: string;
+  tokenName?: string;
+}
+
+export interface IImageProviderOptionsNative extends IDecoratorImageProviderOptions<
+  IImageProviderNativeClientRecord,
+  IImageProviderNativeClientOptions
+> {}
+
+@ImageProvider<IImageProviderOptionsNative>({
+  base: {
+    subdir: 'default',
+    signedDeliveryKind: 'proxy',
+  },
+})
+export class ImageProviderNative extends BeanBase implements IImageProviderExecute {
+  async upload(
+    input: IImageUploadInput,
+    clientOptions: IImageProviderNativeClientOptions,
+    _options: IImageProviderOptionsNative,
+  ): Promise<IImageProviderResource> {
+    const resource = await this.scope.service.imageNative.upload(input, clientOptions);
+    return {
+      ...resource,
+      filename: input.filename,
+      contentType: input.contentType,
+      meta: input.meta,
+    };
+  }
+
+  async get(
+    image: EntityImage,
+    clientOptions: IImageProviderNativeClientOptions,
+    _options: IImageProviderOptionsNative,
+  ) {
+    return {
+      resourceId: image.resourceId,
+      filename: image.filename,
+      contentType: image.contentType,
+      size: image.size,
+      width: image.width,
+      height: image.height,
+      requireSignedURLs: image.requireSignedURLs,
+      variants: image.variants,
+      meta: image.meta,
+      storagePath: image.storagePath,
+      deliveryBaseUrl: image.deliveryBaseUrl ?? clientOptions.deliveryBaseUrl,
+    };
+  }
+
+  async delete(
+    image: EntityImage,
+    _clientOptions: IImageProviderClientOptions,
+    _options: IImageProviderOptionsNative,
+  ) {
+    await this.scope.service.imageNative.remove(image);
+  }
+
+  async getVariantUrl(
+    image: EntityImage,
+    request: IImageVariantRequest,
+    clientOptions: IImageProviderNativeClientOptions,
+    _options: IImageProviderOptionsNative,
+    deliveryOptions?: IImageDeliveryOptions,
+  ) {
+    return await this.scope.service.imageNative.getVariantUrl(
+      image,
+      request,
+      {
+        ...clientOptions,
+        subdir: clientOptions.subdir ?? 'default',
+        deliveryBaseUrl: image.deliveryBaseUrl ?? clientOptions.deliveryBaseUrl,
+      },
+      deliveryOptions,
+    );
+  }
+
+  async download(
+    image: EntityImage,
+    request: IImageVariantRequest,
+    clientOptions: IImageProviderNativeClientOptions,
+    options: IImageProviderOptionsNative,
+    deliveryOptions?: IImageDeliveryOptions,
+  ): Promise<IImageDownloadResult> {
+    if (
+      (deliveryOptions?.responseMode ?? 'auto') !== 'url' &&
+      !deliveryOptions?.signed &&
+      request.variantName === 'original' &&
+      !request.transformOptions
+    ) {
+      const buffer = image.storagePath ? await fse.readFile(image.storagePath) : undefined;
+      if (buffer) {
+        return {
+          kind: 'buffer',
+          buffer,
+          filename: image.filename,
+          contentType: image.contentType,
+          signed: false,
+        };
+      }
+    }
+    return {
+      kind: 'url',
+      url: await this.getVariantUrl(image, request, clientOptions, options, deliveryOptions),
+      filename: image.filename,
+      contentType: image.contentType,
+      signed: !!deliveryOptions?.signed,
+    };
+  }
+}

package/vona/src/suite-vendor/a-image/modules/image-native/src/config/config.ts

@@ -0,0 +1,11 @@
+import type { VonaApplication } from 'vona';
+
+export function config(_app: VonaApplication) {
+  return {
+    imageNative: {
+      variants: {
+        original: {},
+      },
+    },
+  };
+}

package/vona/src/suite-vendor/a-image/modules/image-native/src/index.ts

@@ -0,0 +1 @@
+export * from './.metadata/index.ts';

package/vona/src/suite-vendor/a-image/modules/image-native/src/monkey.ts

@@ -0,0 +1,33 @@
+import type { IMonkeyAppStart } from 'vona';
+
+import fse from 'fs-extra';
+import path from 'node:path';
+import { BeanSimple, cast, getPlatformArch, resolveAddon } from 'vona';
+
+const __Version = '8.18.3';
+
+const __MapTargetNames = {
+  'linux-arm64': `libvips-cpp.so.${__Version}`,
+  'linux-x64': `libvips-cpp.so.${__Version}`,
+  'darwin-arm64': `libvips-cpp.${__Version}.dylib`,
+  'darwin-x64': `libvips-cpp.${__Version}.dylib`,
+  'win32-x64': 'libvips-42.dll',
+};
+
+export class Monkey extends BeanSimple implements IMonkeyAppStart {
+  async appStart() {
+    cast(this.app).__prepareSharpLibvips = () => {
+      const platformArch = getPlatformArch();
+      const addonFileSrc = resolveAddon('sharpLibvips');
+      const addonDirDest = path.join(
+        import.meta.dirname,
+        `node_modules/@img/sharp-libvips-${platformArch}/lib`,
+      );
+      const addonFileDest = path.join(addonDirDest, __MapTargetNames[platformArch]);
+      if (!fse.existsSync(addonFileDest)) {
+        fse.ensureDirSync(addonDirDest);
+        fse.copyFileSync(addonFileSrc, addonFileDest);
+      }
+    };
+  }
+}

package/vona/src/suite-vendor/a-image/modules/image-native/src/service/imageNative.ts

@@ -0,0 +1,291 @@
+import type { SharpConstructor } from 'sharp';
+import type {
+  EntityImage,
+  IImageDeliveryOptions,
+  IImageNamedVariants,
+  IImageProviderResolvedVariant,
+  IImageProviderResource,
+  IImageTransformOptions,
+  IImageUploadInput,
+  IImageVariantRequest,
+} from 'vona-module-a-image';
+
+import fse from 'fs-extra';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { BeanBase, uuidv4 } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { resolveImageVariantRequestToTransform } from 'vona-module-a-image';
+
+import type { IImageProviderNativeClientOptions } from '../bean/imageProvider.native.ts';
+
+type IImageNativeStoredImage = Pick<
+  EntityImage,
+  'resourceId' | 'filename' | 'storagePath' | 'variants'
+>;
+
+@Service()
+export class ServiceImageNative extends BeanBase {
+  private _sharpInstance: SharpConstructor;
+
+  private async getSharp() {
+    if (!this._sharpInstance) {
+      this._sharpInstance = (await import('sharp')).default;
+    }
+    return this._sharpInstance;
+  }
+
+  async upload(
+    input: IImageUploadInput,
+    options: IImageProviderNativeClientOptions,
+  ): Promise<IImageProviderResource> {
+    const publicPath = await this.app.util.getPublicPathPhysical(
+      path.join('image-native', options.subdir ?? 'default'),
+      true,
+    );
+    const resourceId = uuidv4();
+    const ext = this._getOriginalExt(input.filename, input.file);
+    const targetName = `${resourceId}${ext}`;
+    const targetPath = path.join(publicPath, targetName);
+    await fse.copy(input.file, targetPath);
+    const sharp = await this.getSharp();
+    const metadata = await sharp(targetPath).metadata();
+    const stat = await fse.stat(targetPath);
+    const variants = options.variants ?? this.scope.config.imageNative.variants;
+    await this._generateNamedVariants(
+      { resourceId, filename: input.filename, storagePath: targetPath, variants },
+      options,
+    );
+    return {
+      resourceId,
+      size: Number(stat.size),
+      width: metadata.width,
+      height: metadata.height,
+      storagePath: targetPath,
+      deliveryBaseUrl: options.deliveryBaseUrl,
+      requireSignedURLs: input.requireSignedURLs ?? options.requireSignedURLs,
+      variants,
+    };
+  }
+
+  async remove(image: IImageNativeStoredImage) {
+    if (!image.storagePath) return;
+    const dir = path.dirname(image.storagePath);
+    if (!(await fse.pathExists(dir))) return;
+    const entries = await fse.readdir(dir);
+    await Promise.all(
+      entries
+        .filter(
+          name =>
+            name === path.basename(image.storagePath!) || name.startsWith(`${image.resourceId}__`),
+        )
+        .map(name => fse.remove(path.join(dir, name))),
+    );
+  }
+
+  async getVariantUrl(
+    image: IImageNativeStoredImage,
+    request: IImageVariantRequest,
+    options: IImageProviderNativeClientOptions,
+    _deliveryOptions?: IImageDeliveryOptions,
+  ) {
+    const resolved = resolveImageVariantRequestToTransform(request, 'original', image.variants);
+    if (
+      resolved.variantName === 'original' &&
+      this._isOriginalTransform(resolved.transformOptions)
+    ) {
+      return await this._getOriginalUrl(image, options);
+    }
+    const targetPath = await this._ensureVariantFile(image, resolved);
+    return await this._buildUrl(targetPath, options.deliveryBaseUrl);
+  }
+
+  private async _generateNamedVariants(
+    image: IImageNativeStoredImage,
+    options: IImageProviderNativeClientOptions,
+  ) {
+    const variantNames = Object.keys(image.variants ?? {}) as Array<
+      keyof NonNullable<IImageNamedVariants>
+    >;
+    for (const variantName of variantNames) {
+      if (variantName === 'original') continue;
+      await this._ensureVariantFile(
+        image,
+        resolveImageVariantRequestToTransform({ variantName }, 'original', image.variants),
+      );
+    }
+    if (!image.variants?.original) return;
+    await this.getVariantUrl(image, { variantName: 'original' }, options);
+  }
+
+  private async _ensureVariantFile(
+    image: IImageNativeStoredImage,
+    resolved: IImageProviderResolvedVariant,
+  ) {
+    if (!image.storagePath) {
+      throw new Error(`Image storage path missing: ${image.resourceId}`);
+    }
+    const targetPath = await this._getVariantAbsolutePath(image, resolved);
+    if (!(await fse.pathExists(targetPath))) {
+      await this._writeTransformedFile(image.storagePath, targetPath, resolved.transformOptions);
+    }
+    return targetPath;
+  }
+
+  private async _writeTransformedFile(
+    sourcePath: string,
+    targetPath: string,
+    transformOptions: IImageTransformOptions,
+  ) {
+    await fse.ensureDir(path.dirname(targetPath));
+    if (this._isOriginalTransform(transformOptions)) {
+      await fse.copy(sourcePath, targetPath, { overwrite: true });
+      return;
+    }
+    const sharp = await this.getSharp();
+    let pipeline = sharp(sourcePath, { failOn: 'none' });
+    const width =
+      transformOptions.width && transformOptions.dpr
+        ? Math.round(transformOptions.width * transformOptions.dpr)
+        : transformOptions.width;
+    const height =
+      transformOptions.height && transformOptions.dpr
+        ? Math.round(transformOptions.height * transformOptions.dpr)
+        : transformOptions.height;
+    if (
+      width ||
+      height ||
+      transformOptions.fit ||
+      transformOptions.gravity ||
+      transformOptions.background
+    ) {
+      pipeline = pipeline.resize({
+        width,
+        height,
+        fit: this._mapFit(transformOptions.fit),
+        position: this._mapGravity(transformOptions.gravity),
+        background: transformOptions.background,
+      });
+    }
+    if (transformOptions.rotate !== undefined) {
+      pipeline = pipeline.rotate(transformOptions.rotate);
+    }
+    if (transformOptions.sharpen !== undefined) {
+      pipeline = pipeline.sharpen({ sigma: transformOptions.sharpen });
+    }
+    const format = this._normalizeFormat(transformOptions.format);
+    if (format === 'jpeg') {
+      pipeline = pipeline.jpeg({ quality: transformOptions.quality });
+    } else if (format === 'png') {
+      pipeline = pipeline.png({ quality: transformOptions.quality });
+    } else if (format === 'webp') {
+      pipeline = pipeline.webp({ quality: transformOptions.quality });
+    } else if (format === 'avif') {
+      pipeline = pipeline.avif({ quality: transformOptions.quality });
+    }
+    await pipeline.toFile(targetPath);
+  }
+
+  private async _getOriginalUrl(
+    image: IImageNativeStoredImage,
+    options: IImageProviderNativeClientOptions,
+  ) {
+    if (!image.storagePath) {
+      throw new Error(`Image storage path missing: ${image.resourceId}`);
+    }
+    return await this._buildUrl(image.storagePath, options.deliveryBaseUrl);
+  }
+
+  private async _buildUrl(targetPath: string, deliveryBaseUrl?: string) {
+    const variantPath = await this._getVariantStaticPath(targetPath);
+    if (deliveryBaseUrl) {
+      return `${deliveryBaseUrl.replace(/\/$/, '')}/${variantPath}`;
+    }
+    return this.app.util.combineStaticPath(`/${variantPath}`);
+  }
+
+  private async _getVariantStaticPath(targetPath: string) {
+    const publicRoot = await this.app.util.getPublicPathPhysical(undefined, true);
+    const relativePath = path.relative(publicRoot, targetPath).split(path.sep).join(path.posix.sep);
+    return path.posix.join('public', this.ctx.instance.id.toString(), relativePath);
+  }
+
+  private async _getVariantAbsolutePath(
+    image: IImageNativeStoredImage,
+    resolved: IImageProviderResolvedVariant,
+  ) {
+    if (!image.storagePath) throw new Error(`Image storage path missing: ${image.resourceId}`);
+    const dir = path.dirname(image.storagePath);
+    const ext = this._getVariantExt(image.filename, image.storagePath, resolved.transformOptions);
+    if (resolved.variantName !== 'custom') {
+      const variantName = this._sanitizeVariantName(resolved.variantName);
+      return path.join(dir, `${image.resourceId}__${variantName}${ext}`);
+    }
+    const cacheKey = this._buildTransformCacheKey(resolved.transformOptions);
+    return path.join(dir, `${image.resourceId}__t_${cacheKey}${ext}`);
+  }
+
+  private _getVariantExt(
+    filename: string | undefined,
+    storagePath: string | undefined,
+    transformOptions: IImageTransformOptions,
+  ) {
+    const format = this._normalizeFormat(transformOptions.format);
+    if (format) {
+      return format === 'jpeg' ? '.jpg' : `.${format}`;
+    }
+    return path.extname(filename ?? '') || path.extname(storagePath ?? '') || '.bin';
+  }
+
+  private _getOriginalExt(filename: string | undefined, filePath: string) {
+    return path.extname(filename ?? '') || path.extname(filePath) || '.bin';
+  }
+
+  private _normalizeFormat(format: IImageTransformOptions['format']) {
+    if (!format || format === 'auto') return undefined;
+    return format === 'jpeg' ? 'jpeg' : format;
+  }
+
+  private _buildTransformCacheKey(transformOptions: IImageTransformOptions) {
+    const stable = this._stableStringify(transformOptions);
+    return createHash('sha1').update(stable).digest('hex').slice(0, 12);
+  }
+
+  private _stableStringify(value: unknown): string {
+    if (Array.isArray(value)) {
+      return `[${value.map(item => this._stableStringify(item)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+      const entries = Object.entries(value as Record<string, unknown>).sort(([a], [b]) =>
+        a.localeCompare(b),
+      );
+      return `{${entries
+        .map(([key, item]) => `${JSON.stringify(key)}:${this._stableStringify(item)}`)
+        .join(',')}}`;
+    }
+    return JSON.stringify(value);
+  }
+
+  private _sanitizeVariantName(variantName: string) {
+    return variantName.replace(/[^\w.-]/g, '-');
+  }
+
+  private _isOriginalTransform(transformOptions: IImageTransformOptions) {
+    return Object.keys(transformOptions).length === 0;
+  }
+
+  private _mapFit(fit: IImageTransformOptions['fit']) {
+    if (fit === 'scale-down') return 'inside' as const;
+    if (fit === 'contain' || fit === 'pad') return 'contain' as const;
+    if (fit === 'cover' || fit === 'crop') return 'cover' as const;
+    return undefined;
+  }
+
+  private _mapGravity(gravity: IImageTransformOptions['gravity']) {
+    if (gravity === 'top') return 'north';
+    if (gravity === 'bottom') return 'south';
+    if (gravity === 'left') return 'west';
+    if (gravity === 'right') return 'east';
+    return 'centre';
+  }
+}

package/vona/src/suite-vendor/a-image/modules/image-native/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist"
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json"]
+}

package/vona/src/suite-vendor/a-image/modules/image-native/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json", "test"]
+}

package/vona/src/suite-vendor/a-image/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "vona-suite-a-image",
+  "version": "5.0.1",
+  "description": "",
+  "author": "",
+  "files": [],
+  "type": "module",
+  "dependencies": {
+    "vona-module-a-image": "workspace:^",
+    "vona-module-image-cloudflare": "workspace:^",
+    "vona-module-image-native": "workspace:^"
+  },
+  "title": "a-image"
+}

package/vona/src/suite-vendor/a-image/tsconfig.base.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../tsconfig.base",
+  "compilerOptions": {}
+}