next-cloudinary 1.4.0 → 1.6.0

package/dist/next-cloudinary.modern.mjs

@@ -88,87 +88,6 @@ var croppingPlugin = {
   plugin: plugin$7
 };
 
-const params = ['art', {
-  prop: 'autoBrightness',
-  effect: 'auto_brightness'
-}, {
-  prop: 'autoColor',
-  effect: 'auto_color'
-}, {
-  prop: 'autoContrast',
-  effect: 'auto_contrast'
-}, {
-  prop: 'assistColorblind',
-  effect: 'assist_colorblind'
-}, 'blackwhite', 'blur', {
-  prop: 'blurFaces',
-  effect: 'blur_faces'
-}, {
-  prop: 'blurRegion',
-  effect: 'blur_region'
-}, 'brightness', {
-  prop: 'brightnessHSB',
-  effect: 'brightness_hsb'
-}, 'cartoonify', 'colorize', 'contrast', 'distort', {
-  prop: 'fillLight',
-  effect: 'fill_light'
-}, 'gamma', {
-  prop: 'gradientFade',
-  effect: 'gradient_fade'
-}, 'grayscale', 'improve', 'negate', {
-  prop: 'oilPaint',
-  effect: 'oil_paint'
-}, 'outline', 'pixelate', {
-  prop: 'pixelateFaces',
-  effect: 'pixelate_faces'
-}, {
-  prop: 'pixelateRegion',
-  effect: 'pixelate_region'
-}, 'redeye', {
-  prop: 'replaceColor',
-  effect: 'replace_color'
-}, 'saturation', 'sepia', 'shadow', 'sharpen', 'shear', {
-  prop: 'simulateColorblind',
-  effect: 'simulate_colorblind'
-}, 'tint', {
-  prop: 'unsharpMask',
-  effect: 'unsharp_mask'
-}, 'vectorize', 'vibrance', 'vignette'];
-const props$6 = params.map(param => param.prop || param);
-function plugin$6({
-  cldImage,
-  options
-} = {}) {
-  params.forEach(key => {
-    const prop = key.prop || key;
-    const effect = key.effect || key;
-    if (options[prop] === true) {
-      cldImage.effect(`e_${effect}`);
-    } else if (typeof options[prop] === 'string') {
-      cldImage.effect(`e_${effect}:${options[prop]}`);
-    }
-  });
-}
-
-var effectsPlugin = {
-  __proto__: null,
-  props: props$6,
-  plugin: plugin$6
-};
-
-/**
- * encodeBase64
- */
-
-function encodeBase64(value) {
-  if (typeof btoa === 'function') {
-    return btoa(value);
-  }
-  if (typeof Buffer !== 'undefined') {
-    return Buffer.from(value).toString('base64');
-  }
-}
-
 // aspectRatio
 
 const primary = {
@@ -236,6 +155,259 @@ const text = {
     qualifier: false
   }
 };
+const effects = {
+  art: {
+    prefix: 'e',
+    qualifier: 'art'
+  },
+  autoBrightness: {
+    prefix: 'e',
+    qualifier: 'auto_brightness'
+  },
+  autoColor: {
+    prefix: 'e',
+    qualifier: 'auto_color'
+  },
+  autoContrast: {
+    prefix: 'e',
+    qualifier: 'auto_contrast'
+  },
+  assistColorblind: {
+    prefix: 'e',
+    qualifier: 'assist_colorblind'
+  },
+  background: {
+    qualifier: 'b'
+  },
+  blackwhite: {
+    prefix: 'e',
+    qualifier: 'blackwhite'
+  },
+  blur: {
+    prefix: 'e',
+    qualifier: 'blur'
+  },
+  blurFaces: {
+    prefix: 'e',
+    qualifier: 'blur_faces'
+  },
+  blurRegion: {
+    prefix: 'e',
+    qualifier: 'blur_region'
+  },
+  border: {
+    qualifier: 'bo'
+  },
+  brightness: {
+    prefix: 'e',
+    qualifier: 'brightness'
+  },
+  brightnessHSB: {
+    prefix: 'e',
+    qualifier: 'brightness_hsb'
+  },
+  cartoonify: {
+    prefix: 'e',
+    qualifier: 'cartoonify'
+  },
+  color: {
+    qualifier: 'co'
+  },
+  colorize: {
+    prefix: 'e',
+    qualifier: 'colorize'
+  },
+  contrast: {
+    prefix: 'e',
+    qualifier: 'contrast'
+  },
+  distort: {
+    prefix: 'e',
+    qualifier: 'distort'
+  },
+  fillLight: {
+    prefix: 'e',
+    qualifier: 'fill_light'
+  },
+  gamma: {
+    prefix: 'e',
+    qualifier: 'gamma'
+  },
+  gradientFade: {
+    prefix: 'e',
+    qualifier: 'gradient_fade'
+  },
+  grayscale: {
+    prefix: 'e',
+    qualifier: 'grayscale'
+  },
+  improve: {
+    prefix: 'e',
+    qualifier: 'improve'
+  },
+  negate: {
+    prefix: 'e',
+    qualifier: 'negate'
+  },
+  oilPaint: {
+    prefix: 'e',
+    qualifier: 'oil_paint'
+  },
+  opacity: {
+    qualifier: 'o'
+  },
+  outline: {
+    prefix: 'e',
+    qualifier: 'outline'
+  },
+  pixelate: {
+    prefix: 'e',
+    qualifier: 'pixelate'
+  },
+  pixelateFaces: {
+    prefix: 'e',
+    qualifier: 'pixelate_faces'
+  },
+  pixelateRegion: {
+    prefix: 'e',
+    qualifier: 'pixelate_region'
+  },
+  redeye: {
+    prefix: 'e',
+    qualifier: 'redeye'
+  },
+  replaceColor: {
+    prefix: 'e',
+    qualifier: 'replace_color'
+  },
+  saturation: {
+    prefix: 'e',
+    qualifier: 'saturation'
+  },
+  sepia: {
+    prefix: 'e',
+    qualifier: 'sepia'
+  },
+  shadow: {
+    prefix: 'e',
+    qualifier: 'shadow'
+  },
+  sharpen: {
+    prefix: 'e',
+    qualifier: 'sharpen'
+  },
+  shear: {
+    prefix: 'e',
+    qualifier: 'shear'
+  },
+  simulateColorblind: {
+    prefix: 'e',
+    qualifier: 'simulate_colorblind'
+  },
+  tint: {
+    prefix: 'e',
+    qualifier: 'tint'
+  },
+  unsharpMask: {
+    prefix: 'e',
+    qualifier: 'unsharp_mask'
+  },
+  vectorize: {
+    prefix: 'e',
+    qualifier: 'vectorize'
+  },
+  vibrance: {
+    prefix: 'e',
+    qualifier: 'vibrance'
+  },
+  vignette: {
+    prefix: 'e',
+    qualifier: 'vignette'
+  }
+};
+
+const props$6 = [...Object.keys(effects), 'effects'];
+function plugin$6({
+  cldImage,
+  options
+} = {}) {
+  // Handle any top-level effect props
+
+  constructTransformationString({
+    effects: effects,
+    options
+  }).filter(t => !!t).forEach(transformation => cldImage.effect(transformation));
+
+  // If we're passing in an effects prop explicitly, treat it as an array of
+  // effects that we need to process
+
+  if (Array.isArray(options.effects)) {
+    options.effects.forEach(effectsSet => {
+      const transformationString = constructTransformationString({
+        effects: effects,
+        options: effectsSet
+      }).filter(t => !!t).join(',');
+      cldImage.effect(transformationString);
+    });
+  }
+
+  /**
+   * constructEffect
+   */
+
+  function constructEffect({
+    effect,
+    value
+  }) {
+    const {
+      prefix,
+      qualifier
+    } = effect;
+    let transformation = '';
+    if (prefix) {
+      transformation = `${prefix}_`;
+    }
+    if (value === true) {
+      return `${transformation}${qualifier}`;
+    } else if (typeof value === 'string' || typeof value === 'number') {
+      if (prefix) {
+        return `${transformation}${qualifier}:${value}`;
+      } else {
+        return `${qualifier}_${value}`;
+      }
+    }
+  }
+  function constructTransformationString({
+    effects,
+    options
+  }) {
+    return Object.keys(effects).map(key => {
+      return constructEffect({
+        effect: effects[key],
+        value: options[key]
+      });
+    });
+  }
+}
+
+var effectsPlugin = {
+  __proto__: null,
+  props: props$6,
+  plugin: plugin$6
+};
+
+/**
+ * encodeBase64
+ */
+
+function encodeBase64(value) {
+  if (typeof btoa === 'function') {
+    return btoa(value);
+  }
+  if (typeof Buffer !== 'undefined') {
+    return Buffer.from(value).toString('base64');
+  }
+}
 
 const _excluded$3 = ["publicId", "url", "position", "text", "effects"];
 const props$5 = ['text', 'overlays'];
@@ -321,14 +493,36 @@ function plugin$5({
     });
 
     // Layer effects
+    // For layer effects we allow both the standard effects to be applied as well
+    // as the primary ones like width and height as those can be used to modify
+    // the layer after it's created
 
     layerEffects.forEach(effect => {
       Object.keys(effect).forEach(key => {
-        if (!primary[key]) return;
-        const {
-          qualifier
-        } = primary[key];
-        primary$1.push(`${qualifier}_${effect[key]}`);
+        if (primary[key]) {
+          const {
+            qualifier
+          } = primary[key];
+          primary$1.push(`${qualifier}_${effect[key]}`);
+        } else if (effects[key]) {
+          const {
+            qualifier,
+            prefix
+          } = effects[key];
+          let transformation = '';
+          if (prefix) {
+            transformation = `${prefix}_`;
+          }
+          if (effect[key] === true) {
+            primary$1.push(`${transformation}${qualifier}`);
+          } else if (typeof effect[key] === 'string' || typeof effect[key] === 'number') {
+            if (prefix) {
+              primary$1.push(`${transformation}${qualifier}:${effect[key]}`);
+            } else {
+              primary$1.push(`${qualifier}_${effect[key]}`);
+            }
+          }
+        }
       });
     });