@visulima/storage 1.0.0-alpha.9 → 1.0.1

package/dist/packem_shared/sharedGet-Cpo7QUyu.js

@@ -1,1019 +0,0 @@
-const FileMetaExample = {
-  value: {
-    createdAt: "2022-12-16T10:35:17.466Z",
-    id: "391c9157ec481ac6-f72b2d884632d7e6-cdeb2056546033e3",
-    modifiedAt: "2022-12-16T10:35:17.470Z"
-  }
-};
-const createParameterGroup = (parameters, groupName) => parameters.map((parameter) => {
-  return {
-    ...parameter,
-    description: `[${groupName}] ${parameter.description}`,
-    // Add extension for better tooling support
-    "x-group": groupName
-  };
-});
-const getTransformationParameters = (transform, format = ["jpeg", "png", "webp", "avif", "tiff", "gif", "mp4", "webm", "mkv", "ogg", "mp3", "wav", "aac", "flac"]) => {
-  if (!transform)
-    return [];
-  const commonParameters = createParameterGroup(
-    [
-      {
-        description: "Output format for the transformed media",
-        in: "query",
-        name: "format",
-        schema: {
-          enum: format,
-          type: "string"
-        }
-      },
-      {
-        description: "Quality setting (0-100 for images, affects compression)",
-        in: "query",
-        name: "quality",
-        schema: {
-          maximum: 100,
-          minimum: 1,
-          type: "integer"
-        }
-      }
-    ],
-    "Common"
-  );
-  const imageParameters = createParameterGroup(
-    [
-      {
-        description: "Desired width in pixels",
-        in: "query",
-        name: "width",
-        schema: {
-          minimum: 1,
-          type: "integer"
-        }
-      },
-      {
-        description: "Desired height in pixels",
-        in: "query",
-        name: "height",
-        schema: {
-          minimum: 1,
-          type: "integer"
-        }
-      },
-      {
-        description: "Resize fit mode",
-        in: "query",
-        name: "fit",
-        schema: {
-          enum: ["cover", "contain", "fill", "inside", "outside"],
-          type: "string"
-        }
-      },
-      {
-        description: "Position for cover/contain fits",
-        in: "query",
-        name: "position",
-        schema: {
-          oneOf: [
-            {
-              enum: ["top", "right", "bottom", "left", "center"],
-              type: "string"
-            },
-            {
-              minimum: 0,
-              type: "integer"
-            }
-          ]
-        }
-      },
-      {
-        description: "Avoid enlarging images smaller than specified dimensions",
-        in: "query",
-        name: "withoutEnlargement",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Avoid reducing images larger than specified dimensions",
-        in: "query",
-        name: "withoutReduction",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Resize kernel algorithm",
-        in: "query",
-        name: "kernel",
-        schema: {
-          enum: ["nearest", "cubic", "mitchell", "lanczos2", "lanczos3"],
-          type: "string"
-        }
-      },
-      {
-        description: "Fast shrink on load for large images",
-        in: "query",
-        name: "fastShrinkOnLoad",
-        schema: {
-          type: "boolean"
-        }
-      },
-      // Crop parameters
-      {
-        description: "Crop area left offset",
-        in: "query",
-        name: "left",
-        schema: {
-          minimum: 0,
-          type: "integer"
-        }
-      },
-      {
-        description: "Crop area top offset",
-        in: "query",
-        name: "top",
-        schema: {
-          minimum: 0,
-          type: "integer"
-        }
-      },
-      {
-        description: "Crop area width",
-        in: "query",
-        name: "cropWidth",
-        schema: {
-          minimum: 1,
-          type: "integer"
-        }
-      },
-      {
-        description: "Crop area height",
-        in: "query",
-        name: "cropHeight",
-        schema: {
-          minimum: 1,
-          type: "integer"
-        }
-      },
-      {
-        description: "Rotation angle in degrees. Note: angles other than 90°, 180°, and 270° require interpolation and may affect quality",
-        in: "query",
-        name: "angle",
-        schema: {
-          type: "number"
-        }
-      },
-      {
-        description: "Background color for rotation (hex, rgb, or color name)",
-        in: "query",
-        name: "background",
-        schema: {
-          type: "string"
-        }
-      },
-      // Image operations
-      {
-        description: "Apply blur effect",
-        in: "query",
-        name: "blur",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Apply sharpening",
-        in: "query",
-        name: "sharpen",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Apply median filter with specified size",
-        in: "query",
-        name: "median",
-        schema: {
-          minimum: 1,
-          type: "integer"
-        }
-      },
-      {
-        description: "Apply CLAHE (Contrast Limited Adaptive Histogram Equalization)",
-        in: "query",
-        name: "clahe",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Apply thresholding with specified value (0-255)",
-        in: "query",
-        name: "threshold",
-        schema: {
-          maximum: 255,
-          minimum: 0,
-          type: "integer"
-        }
-      },
-      {
-        description: "Apply gamma correction",
-        in: "query",
-        name: "gamma",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Negate (invert) the image",
-        in: "query",
-        name: "negate",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Normalise the image",
-        in: "query",
-        name: "normalise",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Flatten alpha channel",
-        in: "query",
-        name: "flatten",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Unflatten alpha channel",
-        in: "query",
-        name: "unflatten",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Flip image vertically",
-        in: "query",
-        name: "flip",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Flop image horizontally",
-        in: "query",
-        name: "flop",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Convert to greyscale",
-        in: "query",
-        name: "greyscale",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Apply modulation effects",
-        in: "query",
-        name: "modulate",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Brightness multiplier for modulation",
-        in: "query",
-        name: "brightness",
-        schema: {
-          type: "number"
-        }
-      },
-      {
-        description: "Saturation multiplier for modulation",
-        in: "query",
-        name: "saturation",
-        schema: {
-          type: "number"
-        }
-      },
-      {
-        description: "Hue rotation in degrees for modulation",
-        in: "query",
-        name: "hue",
-        schema: {
-          type: "integer"
-        }
-      },
-      {
-        description: "Lightness adjustment for modulation",
-        in: "query",
-        name: "lightness",
-        schema: {
-          type: "integer"
-        }
-      },
-      {
-        description: "Apply tinting",
-        in: "query",
-        name: "tint",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Convert colourspace",
-        in: "query",
-        name: "colourspace",
-        schema: {
-          enum: ["srgb", "rgb", "cmyk", "lab", "b-w"],
-          type: "string"
-        }
-      },
-      {
-        description: "Apply affine transformation",
-        in: "query",
-        name: "affine",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Apply dilation",
-        in: "query",
-        name: "dilate",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Apply erosion",
-        in: "query",
-        name: "erode",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Set pipeline colourspace",
-        in: "query",
-        name: "pipelineColourspace",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Convert to colourspace",
-        in: "query",
-        name: "toColourspace",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Remove alpha channel",
-        in: "query",
-        name: "removeAlpha",
-        schema: {
-          type: "boolean"
-        }
-      },
-      {
-        description: "Ensure alpha channel",
-        in: "query",
-        name: "ensureAlpha",
-        schema: {
-          type: "boolean"
-        }
-      }
-    ],
-    "Image"
-  );
-  const videoParameters = createParameterGroup(
-    [
-      {
-        description: "Desired width in pixels",
-        in: "query",
-        name: "width",
-        schema: {
-          minimum: 1,
-          type: "integer"
-        }
-      },
-      {
-        description: "Desired height in pixels",
-        in: "query",
-        name: "height",
-        schema: {
-          minimum: 1,
-          type: "integer"
-        }
-      },
-      {
-        description: "Video frame rate in Hz",
-        in: "query",
-        name: "frameRate",
-        schema: {
-          minimum: 1,
-          type: "number"
-        }
-      },
-      {
-        description: "Video key frame interval in seconds",
-        in: "query",
-        name: "keyFrameInterval",
-        schema: {
-          minimum: 0.1,
-          type: "number"
-        }
-      }
-    ],
-    "Video"
-  );
-  const videoAudioParameters = createParameterGroup(
-    [
-      {
-        description: "Target bitrate in bits per second",
-        in: "query",
-        name: "bitrate",
-        schema: {
-          minimum: 1,
-          type: "integer"
-        }
-      },
-      {
-        description: "Video or audio codec",
-        in: "query",
-        name: "codec",
-        schema: {
-          enum: ["avc", "hevc", "vp8", "vp9", "av1", "aac", "opus", "mp3", "vorbis", "flac"],
-          type: "string"
-        }
-      }
-    ],
-    "Video/Audio"
-  );
-  const audioParameters = createParameterGroup(
-    [
-      {
-        description: "Audio channel count",
-        in: "query",
-        name: "numberOfChannels",
-        schema: {
-          enum: [1, 2, 3, 4, 5, 6, 7, 8],
-          type: "integer"
-        }
-      },
-      {
-        description: "Audio sample rate in Hz",
-        in: "query",
-        name: "sampleRate",
-        schema: {
-          enum: [8e3, 11025, 16e3, 22050, 32e3, 44100, 48e3, 88200, 96e3, 192e3],
-          type: "integer"
-        }
-      }
-    ],
-    "Audio"
-  );
-  let parameters = [];
-  parameters = [...parameters, ...commonParameters];
-  if (transform === true || transform === "image") {
-    parameters = [...parameters, ...imageParameters];
-  }
-  if (transform === true || transform === "video") {
-    parameters = [...parameters, ...videoParameters];
-  }
-  if (transform === true || transform === "video" || transform === "audio") {
-    parameters = [...parameters, ...videoAudioParameters];
-  }
-  if (transform === true || transform === "audio") {
-    parameters = [...parameters, ...audioParameters];
-  }
-  const seen = /* @__PURE__ */ new Set();
-  return parameters.filter((parameter) => {
-    if (seen.has(parameter.name)) {
-      return false;
-    }
-    seen.add(parameter.name);
-    return true;
-  });
-};
-const getOrganizedTransformationParameters = (transform, format = ["jpeg", "png", "webp", "avif", "tiff", "gif", "mp4", "webm", "mkv", "ogg", "mp3", "wav", "aac", "flac"]) => {
-  const parameters = getTransformationParameters(transform, format);
-  const groups = {};
-  parameters.forEach((parameter) => {
-    const group = parameter["x-group"] || "Other";
-    if (!groups[group]) {
-      groups[group] = [];
-    }
-    groups[group].push(parameter.name);
-  });
-  return { groups, parameters };
-};
-const getTransformationHeaders = (transform) => {
-  if (!transform)
-    return {};
-  const headers = {
-    "X-Media-Type": {
-      description: "Type of media (image/video/audio)",
-      schema: {
-        enum: ["image", "video", "audio"],
-        type: "string"
-      }
-    },
-    "X-Original-Format": {
-      description: "Original file format",
-      schema: {
-        type: "string"
-      }
-    },
-    "X-Transformed-Format": {
-      description: "Transformed file format",
-      schema: {
-        type: "string"
-      }
-    }
-  };
-  return headers;
-};
-const getTransformationErrorResponses = (transform) => {
-  if (!transform)
-    return {};
-  return {
-    400: {
-      content: {
-        "application/json": {
-          examples: {
-            ValidationError: {
-              value: {
-                error: {
-                  code: "INVALID_PARAMS_FOR_IMAGE",
-                  details: {
-                    invalidParams: ["codec", "bitrate"],
-                    mediaType: "image",
-                    validParams: [
-                      "format",
-                      "quality",
-                      "width",
-                      "height",
-                      "fit",
-                      "position",
-                      "withoutEnlargement",
-                      "withoutReduction",
-                      "kernel",
-                      "fastShrinkOnLoad",
-                      "left",
-                      "top",
-                      "cropWidth",
-                      "cropHeight",
-                      "angle",
-                      "background",
-                      "blur",
-                      "sharpen",
-                      "median",
-                      "clahe",
-                      "threshold",
-                      "gamma",
-                      "negate",
-                      "normalise",
-                      "flatten",
-                      "unflatten",
-                      "flip",
-                      "flop",
-                      "greyscale",
-                      "modulate",
-                      "brightness",
-                      "saturation",
-                      "hue",
-                      "lightness",
-                      "tint",
-                      "colourspace",
-                      "affine",
-                      "dilate",
-                      "erode",
-                      "pipelineColourspace",
-                      "toColourspace",
-                      "removeAlpha",
-                      "ensureAlpha"
-                    ]
-                  },
-                  message: "Invalid query parameters for image transformation: codec, bitrate. Images support: format, quality, width, height, fit, position, withoutEnlargement, withoutReduction, kernel, fastShrinkOnLoad, left, top, cropWidth, cropHeight, angle, background, blur, sharpen, median, clahe, threshold, gamma, negate, normalise, flatten, unflatten, flip, flop, greyscale, modulate, brightness, saturation, hue, lightness, tint, colourspace, affine, dilate, erode, pipelineColourspace, toColourspace, removeAlpha, ensureAlpha. Video/audio parameters (codec, bitrate) are not supported for images.",
-                  name: "ValidationError"
-                }
-              }
-            }
-          },
-          schema: {
-            $ref: "#/components/schemas/ValidationError"
-          }
-        }
-      },
-      description: "Invalid transformation parameters"
-    },
-    413: {
-      content: {
-        "application/json": {
-          schema: {
-            $ref: "#/components/schemas/Error"
-          }
-        }
-      },
-      description: "File too large for transformation"
-    },
-    415: {
-      content: {
-        "application/json": {
-          schema: {
-            $ref: "#/components/schemas/Error"
-          }
-        }
-      },
-      description: "Unsupported media type for transformation"
-    }
-  };
-};
-const sharedGet = (operationId, tags, transform, transformerFormat) => {
-  return {
-    description: "Get the uploaded file with optional media transformation support",
-    operationId,
-    parameters: [
-      {
-        in: "path",
-        name: "id",
-        required: true,
-        schema: {
-          type: "string"
-        }
-      },
-      ...getTransformationParameters(transform, transformerFormat)
-    ],
-    responses: {
-      200: {
-        content: {
-          "*/*": {
-            schema: {
-              description: transform ? "Transformed file content" : "File content",
-              format: "binary",
-              type: "string"
-            }
-          }
-        },
-        description: transform ? "File retrieved and transformed successfully" : "File retrieved successfully",
-        headers: {
-          "Content-Type": {
-            description: `MIME type of the file${transform ? " (or transformed file)" : ""}`,
-            schema: {
-              type: "string"
-            }
-          },
-          ETag: {
-            description: `Upload ETag${transform ? " (or transformed file ETag)" : ""}`,
-            schema: {
-              example: "d41d8cd98f00b204e9800998ecf8427e",
-              type: "string"
-            }
-          },
-          "Last-Modified": {
-            description: "Upload last modified date",
-            schema: {
-              example: "2021-08-25T11:12:26.635Z",
-              format: "date-time",
-              type: "string"
-            }
-          },
-          ...getTransformationHeaders(transform),
-          "X-Upload-Expires": {
-            description: "Upload expiration date",
-            schema: {
-              example: "2021-08-25T11:12:26.635Z",
-              format: "date-time",
-              type: "string"
-            }
-          }
-        }
-      },
-      ...getTransformationErrorResponses(transform),
-      404: {
-        content: {
-          "application/json": {
-            example: {
-              error: {
-                code: "FileNotFound",
-                message: "Not found"
-              }
-            },
-            schema: {
-              $ref: "#/components/schemas/Error"
-            }
-          }
-        },
-        description: "Not Found"
-      },
-      default: {
-        content: {
-          "application/json": {
-            schema: {
-              $ref: "#/components/schemas/Error"
-            }
-          }
-        },
-        description: "Error"
-      }
-    },
-    summary: "Get the uploaded file",
-    tags
-  };
-};
-const sharedGetMeta = (operationId, tags) => {
-  return {
-    description: "Get the uploaded file metadata",
-    operationId,
-    parameters: [
-      {
-        in: "path",
-        name: "id",
-        required: true,
-        schema: {
-          type: "string"
-        }
-      }
-    ],
-    responses: {
-      200: {
-        content: {
-          "application/json": {
-            schema: {
-              $ref: "#/components/schemas/FileMeta"
-            }
-          }
-        },
-        description: "OK",
-        headers: {
-          "Last-Modified": {
-            description: "Upload last modified date",
-            schema: {
-              example: "2021-08-25T11:12:26.635Z",
-              format: "date-time",
-              type: "string"
-            }
-          },
-          "X-Upload-Expires": {
-            description: "Upload expiration date",
-            schema: {
-              example: "2021-08-25T11:12:26.635Z",
-              format: "date-time",
-              type: "string"
-            }
-          }
-        }
-      },
-      404: {
-        content: {
-          "application/json": {
-            example: {
-              error: {
-                code: "FileNotFound",
-                message: "File metadata not found"
-              }
-            },
-            schema: {
-              $ref: "#/components/schemas/Error"
-            }
-          }
-        },
-        description: "Not Found"
-      },
-      default: {
-        content: {
-          "application/json": {
-            schema: {
-              $ref: "#/components/schemas/Error"
-            }
-          }
-        },
-        description: "Error"
-      }
-    },
-    summary: "Get the uploaded file metadata",
-    tags
-  };
-};
-const sharedErrorSchemaObject = {
-  Error: {
-    description: "Error",
-    properties: {
-      error: {
-        properties: {
-          code: {
-            minLength: 1,
-            type: "string"
-          },
-          message: {
-            minLength: 1,
-            type: "string"
-          },
-          name: {
-            minLength: 3,
-            type: "string"
-          }
-        },
-        required: ["message"],
-        type: "object"
-      }
-    },
-    required: ["error"],
-    type: "object"
-  },
-  // Validation error schema
-  ValidationError: {
-    description: "Validation error response",
-    properties: {
-      code: {
-        enum: [
-          "INVALID_PARAMS_FOR_IMAGE",
-          "INVALID_PARAMS_FOR_VIDEO",
-          "INVALID_PARAMS_FOR_AUDIO",
-          "INVALID_FIT_VALUE",
-          "INVALID_ANGLE_VALUE",
-          "INVALID_FORMAT",
-          "INCOMPLETE_CROP_PARAMS",
-          "INVALID_VIDEO_CODEC",
-          "INVALID_VIDEO_FORMAT",
-          "INVALID_WIDTH",
-          "INVALID_HEIGHT",
-          "INVALID_BITRATE",
-          "INVALID_FRAME_RATE",
-          "INVALID_KEY_FRAME_INTERVAL",
-          "INVALID_AUDIO_CODEC",
-          "INVALID_AUDIO_FORMAT",
-          "INVALID_CHANNEL_COUNT",
-          "INVALID_SAMPLE_RATE"
-        ],
-        type: "string"
-      },
-      details: {
-        properties: {
-          invalidParams: {
-            items: {
-              type: "string"
-            },
-            type: "array"
-          },
-          mediaType: {
-            enum: ["image", "video", "audio"],
-            type: "string"
-          },
-          suggestions: {
-            items: {
-              type: "string"
-            },
-            type: "array"
-          },
-          validParams: {
-            items: {
-              type: "string"
-            },
-            type: "array"
-          }
-        },
-        required: ["invalidParams", "validParams", "mediaType"],
-        type: "object"
-      },
-      message: {
-        type: "string"
-      },
-      name: {
-        enum: ["ValidationError"],
-        type: "string"
-      }
-    },
-    required: ["code", "details", "message", "name"],
-    type: "object"
-  }
-};
-const sharedFileMetaSchemaObject = {
-  FileMeta: {
-    description: "File meta",
-    properties: {
-      bytesWritten: {
-        type: "integer"
-      },
-      contentType: {
-        type: "string"
-      },
-      createdAt: {
-        format: "date-time",
-        type: "string"
-      },
-      id: {
-        minLength: 1,
-        type: "string"
-      },
-      metadata: {
-        type: "object"
-      },
-      name: {
-        minLength: 1,
-        type: "string"
-      },
-      originalName: {
-        minLength: 1,
-        type: "string"
-      },
-      status: {
-        enum: ["completed", "part", "deleted", "created"],
-        type: "string"
-      }
-    },
-    type: "object"
-  }
-};
-const sharedFileMetaExampleObject = {
-  FileMeta: {
-    value: [FileMetaExample]
-  },
-  FileMetaPagination: {
-    value: {
-      data: [FileMetaExample.value],
-      meta: {
-        firstPage: 1,
-        firstPageUrl: "/?page=1",
-        lastPage: 1,
-        lastPageUrl: "/?page=10",
-        nextPageUrl: "/?page=2",
-        page: 1,
-        perPage: 1,
-        previousPageUrl: void 0,
-        total: 1
-      }
-    }
-  }
-};
-const sharedGetList = (operationId, tags) => {
-  return {
-    description: "List upload",
-    operationId,
-    parameters: [
-      {
-        description: "Maximum number of elements to retrieve.",
-        in: "query",
-        name: "limit",
-        schema: {
-          nullable: true,
-          type: "integer"
-        }
-      },
-      {
-        description: "Page number. Use only for pagination.",
-        in: "query",
-        name: "page",
-        schema: {
-          nullable: true,
-          type: "integer"
-        }
-      }
-    ],
-    responses: {
-      200: {
-        content: {
-          "application/json": {
-            examples: {
-              Default: {
-                $ref: "#/components/examples/FileMeta"
-              },
-              Pagination: {
-                $ref: "#/components/examples/FileMetaPagination"
-              }
-            },
-            schema: {
-              $ref: "#/components/schemas/FileMeta"
-            }
-          }
-        },
-        description: "OK"
-      },
-      default: {
-        content: {
-          "application/json": {
-            schema: {
-              $ref: "#/components/schemas/Error"
-            }
-          }
-        },
-        description: "Error"
-      }
-    },
-    summary: "List upload",
-    tags
-  };
-};
-
-export { getOrganizedTransformationParameters, sharedErrorSchemaObject, sharedFileMetaExampleObject, sharedFileMetaSchemaObject, sharedGet, sharedGetList, sharedGetMeta };