decap-cms-lib-util 3.3.0 → 3.4.0

package/dist/esm/API.js

@@ -1,28 +1,7 @@
-function _extendableBuiltin(cls) {
-  function ExtendableBuiltin() {
-    var instance = Reflect.construct(cls, Array.from(arguments));
-    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
-    return instance;
-  }
-  ExtendableBuiltin.prototype = Object.create(cls.prototype, {
-    constructor: {
-      value: cls,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    }
-  });
-  if (Object.setPrototypeOf) {
-    Object.setPrototypeOf(ExtendableBuiltin, cls);
-  } else {
-    ExtendableBuiltin.__proto__ = cls;
-  }
-  return ExtendableBuiltin;
-}
 import { asyncLock } from './asyncLock';
 import unsentRequest from './unsentRequest';
 import APIError from './APIError';
-class RateLimitError extends _extendableBuiltin(Error) {
+class RateLimitError extends Error {
   constructor(message, resetSeconds) {
     super(message);
     if (resetSeconds < 0) {

package/dist/esm/APIError.js

@@ -1,26 +1,5 @@
-function _extendableBuiltin(cls) {
-  function ExtendableBuiltin() {
-    var instance = Reflect.construct(cls, Array.from(arguments));
-    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
-    return instance;
-  }
-  ExtendableBuiltin.prototype = Object.create(cls.prototype, {
-    constructor: {
-      value: cls,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    }
-  });
-  if (Object.setPrototypeOf) {
-    Object.setPrototypeOf(ExtendableBuiltin, cls);
-  } else {
-    ExtendableBuiltin.__proto__ = cls;
-  }
-  return ExtendableBuiltin;
-}
 export const API_ERROR = 'API_ERROR';
-export default class APIError extends _extendableBuiltin(Error) {
+export default class APIError extends Error {
   constructor(message, status, api, meta = {}) {
     super(message);
     this.message = message;

package/dist/esm/AccessTokenError.js

@@ -1,26 +1,5 @@
-function _extendableBuiltin(cls) {
-  function ExtendableBuiltin() {
-    var instance = Reflect.construct(cls, Array.from(arguments));
-    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
-    return instance;
-  }
-  ExtendableBuiltin.prototype = Object.create(cls.prototype, {
-    constructor: {
-      value: cls,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    }
-  });
-  if (Object.setPrototypeOf) {
-    Object.setPrototypeOf(ExtendableBuiltin, cls);
-  } else {
-    ExtendableBuiltin.__proto__ = cls;
-  }
-  return ExtendableBuiltin;
-}
 export const ACCESS_TOKEN_ERROR = 'ACCESS_TOKEN_ERROR';
-export default class AccessTokenError extends _extendableBuiltin(Error) {
+export default class AccessTokenError extends Error {
   constructor(message) {
     super(message);
     this.message = message;

package/dist/esm/EditorialWorkflowError.js

@@ -1,26 +1,5 @@
-function _extendableBuiltin(cls) {
-  function ExtendableBuiltin() {
-    var instance = Reflect.construct(cls, Array.from(arguments));
-    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
-    return instance;
-  }
-  ExtendableBuiltin.prototype = Object.create(cls.prototype, {
-    constructor: {
-      value: cls,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    }
-  });
-  if (Object.setPrototypeOf) {
-    Object.setPrototypeOf(ExtendableBuiltin, cls);
-  } else {
-    ExtendableBuiltin.__proto__ = cls;
-  }
-  return ExtendableBuiltin;
-}
 export const EDITORIAL_WORKFLOW_ERROR = 'EDITORIAL_WORKFLOW_ERROR';
-export default class EditorialWorkflowError extends _extendableBuiltin(Error) {
+export default class EditorialWorkflowError extends Error {
   constructor(message, notUnderEditorialWorkflow) {
     super(message);
     this.message = message;

package/dist/esm/path.js

@@ -1,9 +1,10 @@
-const absolutePath = new RegExp('^(?:[a-z]+:)?//', 'i');
+const absolutePath = new RegExp('^(?:[a-z]+:)?//|^/', 'i');
 function normalizePath(path) {
   return path.replace(/[\\/]+/g, '/');
 }
 export function isAbsolutePath(path) {
-  return absolutePath.test(path);
+  const result = absolutePath.test(path);
+  return result;
 }
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "decap-cms-lib-util",
   "description": "Shared utilities for Decap CMS.",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "repository": "https://github.com/decaporg/decap-cms/tree/main/packages/decap-cms-lib-util",
   "bugs": "https://github.com/decaporg/decap-cms/issues",
   "module": "dist/esm/index.js",
@@ -28,5 +28,5 @@
     "immutable": "^3.7.6",
     "lodash": "^4.17.11"
   },
-  "gitHead": "ed7e99318007b83f4c57f3237bf92b931676820a"
+  "gitHead": "0c1b7c7d63ba6ddb3de3692fbb6b16ac6ebb44d5"
 }

package/dist/esm/stega.js

@@ -1,129 +0,0 @@
-import { vercelStegaEncode } from '@vercel/stega';
-import { isImmutableMap, isImmutableList } from './types';
-
-/**
- * Context passed to encode functions, containing the current state of the encoding process
- */
-
-/**
- * Get the fields that should be used for encoding nested values
- */
-function getNestedFields(f) {
-  if (f) {
-    if ('types' in f) {
-      var _f$types;
-      return (_f$types = f.types) !== null && _f$types !== void 0 ? _f$types : [];
-    }
-    if ('fields' in f) {
-      var _f$fields;
-      return (_f$fields = f.fields) !== null && _f$fields !== void 0 ? _f$fields : [];
-    }
-    if ('field' in f) {
-      return f.field ? [f.field] : [];
-    }
-    return [f];
-  }
-  return [];
-}
-
-/**
- * Encode a string value by appending steganographic data
- * For markdown fields, encode each paragraph separately
- */
-function encodeString(value, {
-  fields,
-  path
-}) {
-  var _fields$;
-  const stega = vercelStegaEncode({
-    decap: path
-  });
-  const isMarkdown = ((_fields$ = fields[0]) === null || _fields$ === void 0 ? void 0 : _fields$.widget) === 'markdown';
-  if (isMarkdown && value.includes('\n\n')) {
-    const blocks = value.split(/(\n\n+)/);
-    return blocks.map(block => block.trim() ? block + stega : block).join('');
-  }
-  return value + stega;
-}
-
-/**
- * Encode a list of values, handling both simple values and nested objects/lists
- * For typed lists, use the type field to determine which fields to use
- */
-function encodeList(list, ctx) {
-  let newList = list;
-  for (let i = 0; i < newList.size; i++) {
-    const item = newList.get(i);
-    if (isImmutableMap(item)) {
-      const itemType = item.get('type');
-      if (typeof itemType === 'string') {
-        // For typed items, look up fields based on type
-        const field = ctx.fields.find(f => f.name === itemType);
-        const newItem = ctx.visit(item, getNestedFields(field), `${ctx.path}.${i}`);
-        newList = newList.set(i, newItem);
-      } else {
-        // For untyped items, use current fields
-        const newItem = ctx.visit(item, ctx.fields, `${ctx.path}.${i}`);
-        newList = newList.set(i, newItem);
-      }
-    } else {
-      // For simple values, use first field if available
-      const field = ctx.fields[0];
-      const newItem = ctx.visit(item, field ? [field] : [], `${ctx.path}.${i}`);
-      if (newItem !== item) {
-        newList = newList.set(i, newItem);
-      }
-    }
-  }
-  return newList;
-}
-
-/**
- * Encode a map of values, looking up the appropriate field for each key
- * and recursively encoding nested values
- */
-function encodeMap(map, ctx) {
-  let newMap = map;
-  for (const [key, val] of newMap.entrySeq().toArray()) {
-    const field = ctx.fields.find(f => f.name === key);
-    if (field) {
-      const fields = getNestedFields(field);
-      const newVal = ctx.visit(val, fields, ctx.path ? `${ctx.path}.${key}` : key);
-      if (newVal !== val) {
-        newMap = newMap.set(key, newVal);
-      }
-    }
-  }
-  return newMap;
-}
-
-/**
- * Main entry point for encoding steganographic data into entry values
- * Uses a visitor pattern with caching to handle recursive structures
- */
-export function encodeEntry(value, fields) {
-  const plainFields = fields.toJS();
-  const cache = new Map();
-  function visit(value, fields, path = '') {
-    const cached = cache.get(path);
-    if (cached === value) return value;
-    const ctx = {
-      fields,
-      path,
-      visit
-    };
-    let result;
-    if (isImmutableList(value)) {
-      result = encodeList(value, ctx);
-    } else if (isImmutableMap(value)) {
-      result = encodeMap(value, ctx);
-    } else if (typeof value === 'string') {
-      result = encodeString(value, ctx);
-    } else {
-      result = value;
-    }
-    cache.set(path, result);
-    return result;
-  }
-  return visit(value, plainFields);
-}