decap-cms-lib-util 3.0.4 → 3.2.0

package/dist/esm/stega.js

@@ -0,0 +1,129 @@
+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);
+}

package/dist/esm/types/semaphore.d.js

@@ -1 +0,0 @@
-"use strict";

package/dist/esm/types.js

@@ -0,0 +1,7 @@
+import { Map as ImmutableMap, List } from 'immutable';
+export function isImmutableMap(value) {
+  return ImmutableMap.isMap(value);
+}
+export function isImmutableList(value) {
+  return List.isList(value);
+}

package/dist/esm/unsentRequest.js

@@ -1,19 +1,12 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _immutable = require("immutable");
-var _curry = _interopRequireDefault(require("lodash/curry"));
-var _flow = _interopRequireDefault(require("lodash/flow"));
-var _isString = _interopRequireDefault(require("lodash/isString"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { fromJS, List, Map } from 'immutable';
+import curry from 'lodash/curry';
+import flow from 'lodash/flow';
+import isString from 'lodash/isString';
 function isAbortControllerSupported() {
   if (typeof window !== 'undefined') {
     return !!window.AbortController;
@@ -40,18 +33,18 @@ function fetchWithTimeout(input, init) {
   });
 }
 function decodeParams(paramsString) {
-  return (0, _immutable.List)(paramsString.split('&')).map(s => (0, _immutable.List)(s.split('=')).map(decodeURIComponent)).update(_immutable.Map);
+  return List(paramsString.split('&')).map(s => List(s.split('=')).map(decodeURIComponent)).update(Map);
 }
 function fromURL(wholeURL) {
   const [url, allParamsString] = wholeURL.split('?');
-  return (0, _immutable.Map)(_objectSpread({
+  return Map(_objectSpread({
     url
   }, allParamsString ? {
     params: decodeParams(allParamsString)
   } : {}));
 }
 function fromFetchArguments(wholeURL, options) {
-  return fromURL(wholeURL).merge((options ? (0, _immutable.fromJS)(options) : (0, _immutable.Map)()).remove('url').remove('params'));
+  return fromURL(wholeURL).merge((options ? fromJS(options) : Map()).remove('url').remove('params'));
 }
 function encodeParams(params) {
   return params.entrySeq().map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join('&');
@@ -63,13 +56,13 @@ function toFetchArguments(req) {
   return [toURL(req), req.remove('url').remove('params').toJS()];
 }
 function maybeRequestArg(req) {
-  if ((0, _isString.default)(req)) {
+  if (isString(req)) {
     return fromURL(req);
   }
   if (req) {
-    return (0, _immutable.fromJS)(req);
+    return fromJS(req);
   }
-  return (0, _immutable.Map)();
+  return Map();
 }
 function ensureRequestArg(func) {
   return req => func(maybeRequestArg(req));
@@ -86,12 +79,12 @@ const performRequest = ensureRequestArg(req => {
 
 // Each of the following functions takes options and returns another
 // function that performs the requested action on a request.
-const getCurriedRequestProcessor = (0, _flow.default)([ensureRequestArg2, _curry.default]);
+const getCurriedRequestProcessor = flow([ensureRequestArg2, curry]);
 function getPropSetFunction(path) {
   return getCurriedRequestProcessor((val, req) => req.setIn(path, val));
 }
 function getPropMergeFunction(path) {
-  return getCurriedRequestProcessor((obj, req) => req.updateIn(path, (p = (0, _immutable.Map)()) => p.merge(obj)));
+  return getCurriedRequestProcessor((obj, req) => req.updateIn(path, (p = Map()) => p.merge(obj)));
 }
 const withMethod = getPropSetFunction(['method']);
 const withBody = getPropSetFunction(['body']);
@@ -107,7 +100,7 @@ const withRoot = getCurriedRequestProcessor((root, req) => req.update('url', p =
   }
   return root && p && p[0] !== '/' && root[root.length - 1] !== '/' ? `${root}/${p}` : `${root}${p}`;
 }));
-var _default = exports.default = {
+export default {
   toURL,
   fromURL,
   fromFetchArguments,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "decap-cms-lib-util",
   "description": "Shared utilities for Decap CMS.",
-  "version": "3.0.4",
+  "version": "3.2.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",
@@ -25,5 +25,5 @@
     "immutable": "^3.7.6",
     "lodash": "^4.17.11"
   },
-  "gitHead": "d3678b0ad1b9f93b841c85e4ee2de48167aa8906"
+  "gitHead": "e2165450e5963b2a8d76d4cf331319bf91f05d45"
 }

package/src/API.ts

@@ -142,6 +142,7 @@ type Backend = 'github' | 'gitlab' | 'bitbucket';
 type RequestConfig = Omit<RequestInit, 'headers'> &
   HeaderConfig & {
     backend: Backend;
+    apiRoot?: string;
     params?: ParamObject;
   };
 
@@ -182,7 +183,7 @@ async function constructRequestHeaders(headerConfig: HeaderConfig) {
   const { token, headers } = headerConfig;
   const baseHeaders: HeaderObj = { 'Content-Type': 'application/json; charset=utf-8', ...headers };
   if (token) {
-    baseHeaders['Authorization'] = `token ${token}`;
+    baseHeaders['Authorization'] = `Bearer ${token}`;
   }
   return Promise.resolve(baseHeaders);
 }
@@ -199,7 +200,7 @@ export async function apiRequest(
   const { token, backend, ...props } = config;
   const options = { cache: 'no-cache', ...props };
   const headers = await constructRequestHeaders({ headers: options.headers || {}, token });
-  const baseUrl = apiRoots[backend];
+  const baseUrl = config.apiRoot ?? apiRoots[backend];
   const url = constructUrlWithParams(`${baseUrl}${path}`, options.params);
   let responseStatus = 500;
   try {
@@ -220,9 +221,10 @@ export async function getDefaultBranchName(configs: {
   backend: Backend;
   repo: string;
   token?: string;
+  apiRoot?: string;
 }) {
   let apiPath;
-  const { token, backend, repo } = configs;
+  const { token, backend, repo, apiRoot } = configs;
   switch (backend) {
     case 'gitlab': {
       apiPath = `/projects/${encodeURIComponent(repo)}`;
@@ -236,7 +238,7 @@ export async function getDefaultBranchName(configs: {
       apiPath = `/repos/${repo}`;
     }
   }
-  const repoInfo = await apiRequest(apiPath, { token, backend });
+  const repoInfo = await apiRequest(apiPath, { token, backend, apiRoot });
   let defaultBranchName;
   if (backend === 'bitbucket') {
     const {

package/src/stega.ts

@@ -0,0 +1,134 @@
+import { vercelStegaEncode } from '@vercel/stega';
+
+import { isImmutableMap, isImmutableList } from './types';
+
+import type { Map as ImmutableMap, List } from 'immutable';
+import type { CmsField } from 'decap-cms-core';
+
+/**
+ * Context passed to encode functions, containing the current state of the encoding process
+ */
+interface EncodeContext {
+  fields: CmsField[]; // Available CMS fields at current level
+  path: string; // Path to current value in object tree
+  visit: (value: unknown, fields: CmsField[], path: string) => unknown; // Visitor for recursive traversal
+}
+
+/**
+ * Get the fields that should be used for encoding nested values
+ */
+function getNestedFields(f?: CmsField): CmsField[] {
+  if (f) {
+    if ('types' in f) {
+      return f.types ?? [];
+    }
+    if ('fields' in f) {
+      return 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: string, { fields, path }: EncodeContext): string {
+  const stega = vercelStegaEncode({ decap: path });
+  const isMarkdown = fields[0]?.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: List<unknown>, ctx: EncodeContext): List<unknown> {
+  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: ImmutableMap<string, unknown>,
+  ctx: EncodeContext,
+): ImmutableMap<string, unknown> {
+  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: unknown, fields: List<ImmutableMap<string, unknown>>) {
+  const plainFields = fields.toJS() as CmsField[];
+  const cache = new Map();
+
+  function visit(value: unknown, fields: CmsField[], path = '') {
+    const cached = cache.get(path);
+    if (cached === value) return value;
+
+    const ctx: EncodeContext = { 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);
+}

package/src/types.ts

@@ -0,0 +1,9 @@
+import { Map as ImmutableMap, List } from 'immutable';
+
+export function isImmutableMap(value: unknown): value is ImmutableMap<string, unknown> {
+  return ImmutableMap.isMap(value);
+}
+
+export function isImmutableList(value: unknown): value is List<unknown> {
+  return List.isList(value);
+}