@parischap/pretty-print
Version:
A functional library to pretty-print and treeify objects
521 lines (519 loc) • 27.7 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.utilInspectLike = exports.treeifyHideLeaves = exports.treeify = exports.toStringifier = exports.moduleTag = exports.make = exports.id = exports.has = exports.equivalence = exports.darkModeUtilInspectLike = exports.darkModeTreeifyHideLeaves = exports.darkModeTreeify = exports.PropertySource = exports.PropertyNumberDisplayOption = exports.NonPrimitive = void 0;
var _ansiStyles = /*#__PURE__*/require("@parischap/ansi-styles");
var _effectLib = /*#__PURE__*/require("@parischap/effect-lib");
var _effect = /*#__PURE__*/require("effect");
var PPByPasser = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./ByPasser.js"));
var PPByPassers = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./ByPassers.js"));
var PPMarkMap = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./MarkMap.js"));
var PPMarkShowerConstructor = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./MarkShowerConstructor.js"));
var PPNonPrimitiveFormatter = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./NonPrimitiveFormatter.js"));
var PPPrimitiveFormatter = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./PrimitiveFormatter.js"));
var PPPropertyFilters = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./PropertyFilters.js"));
var PPPropertyFormatter = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./PropertyFormatter.js"));
var PPStringifiedValue = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./StringifiedValue.js"));
var PPStyleMap = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./StyleMap.js"));
var PPValue = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./Value.js"));
var PPValueBasedStylerConstructor = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./ValueBasedStylerConstructor.js"));
var PPValues = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("./Values.js"));
function _getRequireWildcardCache(e) {
if ("function" != typeof WeakMap) return null;
var r = new WeakMap(),
t = new WeakMap();
return (_getRequireWildcardCache = function (e) {
return e ? t : r;
})(e);
}
function _interopRequireWildcard(e, r) {
if (!r && e && e.__esModule) return e;
if (null === e || "object" != typeof e && "function" != typeof e) return {
default: e
};
var t = _getRequireWildcardCache(r);
if (t && t.has(e)) return t.get(e);
var n = {
__proto__: null
},
a = Object.defineProperty && Object.getOwnPropertyDescriptor;
for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) {
var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
}
return n.default = e, t && t.set(e, n), n;
}
/**
* This module implements the options for pretty-printing.
*
* With the make function, you can define your own instances if the provided ones don't suit your
* needs.
*/
/**
* Module tag
*
* @category Models
*/
const moduleTag = exports.moduleTag = '@parischap/pretty-print/Option/';
const _TypeId = /*#__PURE__*/Symbol.for(moduleTag);
/**
* Namespace for the possible sources of properties for non-primitive values
*
* @category Models
*/
var PropertySource;
(function (PropertySource) {
/**
* Type of a PropertySource
*
* @category Models
*/
let Type;
(function (Type) {
/**
* Properties are obtained by calling Reflect.getOwnProperties on the non-primitive-value and
* its prototypes (until maxPrototypeDepth is reached). This is usually a good choice for
* records
*/
Type[Type["FromProperties"] = 0] = "FromProperties";
/**
* Properties are obtained by iterating over the non-primitive-value that must implement the
* Iterable protocol. Each value returned by the iterator is used to create a property with an
* auto-incremented numerical key (converted to a string). This is usually a good choice for
* arrays and sets.
*/
Type[Type["FromValueIterable"] = 1] = "FromValueIterable";
/**
* Properties are obtained by iterating over the non-primitive-value that must implement the
* Iterable protocol. The iterator must return a key/value pair. Otherwise, the returned value
* is ignored. This is usually a good choice for maps,...
*/
Type[Type["FromKeyValueIterable"] = 2] = "FromKeyValueIterable";
})(Type = PropertySource.Type || (PropertySource.Type = {}));
})(PropertySource || (exports.PropertySource = PropertySource = {}));
/**
* Namespace for the options regarding the display of the number of properties of a non-primitive
* value. The number of properties is shown in between parentheses just after the non-primitive
* value id.
*
* @category Models
*/
var PropertyNumberDisplayOption;
(function (PropertyNumberDisplayOption) {
/**
* Type of a PropertyNumberDisplayOption
*
* @category Models
*/
let Type;
(function (Type) {
/** The number of properties is not shown */
Type[Type["None"] = 0] = "None";
/** Shows the number of properties retrieved from the property source */
Type[Type["All"] = 1] = "All";
/**
* Shows the number of properties actually displayed, i.e. these remaining after filtering,
* deduping and applying `maxPropertyNumber`
*/
Type[Type["Actual"] = 2] = "Actual";
/**
* Shows both the number of properties retrieved from the property source and the number of
* properties actually displayed (after filtering, deduping and applying `maxPropertyNumber`)
*/
Type[Type["AllAndActual"] = 3] = "AllAndActual";
/**
* Shows both the number of properties retrieved from the property source and the number of
* properties actually displayed (after filtering, deduping and applying `maxPropertyNumber`)
* only if these two numbers are different. Otherwise, does not show anything
*/
Type[Type["AllAndActualIfDifferent"] = 4] = "AllAndActualIfDifferent";
})(Type = PropertyNumberDisplayOption.Type || (PropertyNumberDisplayOption.Type = {}));
})(PropertyNumberDisplayOption || (exports.PropertyNumberDisplayOption = PropertyNumberDisplayOption = {}));
/**
* Namespace for the options for pretty printing non-primitive values
*
* @category Models
*/
var NonPrimitive;
(function (NonPrimitive) {
const namespaceTag = moduleTag + 'NonPrimitive/';
const _TypeId = /*#__PURE__*/Symbol.for(namespaceTag);
/**
* Type guard
*
* @category Guards
*/
NonPrimitive.has = u => _effect.Predicate.hasProperty(u, _TypeId);
/**
* Equivalence
*
* @category Equivalences
*/
NonPrimitive.equivalence = (self, that) => that.id === self.id;
/** Prototype */
const _TypeIdHash = /*#__PURE__*/_effect.Hash.hash(_TypeId);
const proto = {
[_TypeId]: _TypeId,
[_effect.Equal.symbol](that) {
return NonPrimitive.has(that) && NonPrimitive.equivalence(this, that);
},
[_effect.Hash.symbol]() {
return (0, _effect.pipe)(this.id, _effect.Hash.hash, _effect.Hash.combine(_TypeIdHash), _effect.Hash.cached(this));
},
[_effectLib.MInspectable.IdSymbol]() {
return this.id;
},
... /*#__PURE__*/_effectLib.MInspectable.BaseProto(namespaceTag),
..._effectLib.MPipeable.BaseProto
};
/**
* Constructor without an id
*
* @category Constructors
*/
NonPrimitive.make = params => _effectLib.MTypes.objectFromDataAndProto(proto, params);
/**
* Returns the `id` property of `self`
*
* @category Destructors
*/
NonPrimitive.id = /*#__PURE__*/_effect.Struct.get('id');
/**
* Defaults NonPrimitive Option instance
*
* @category Instances
*/
NonPrimitive.record = /*#__PURE__*/NonPrimitive.make({
id: 'Object',
showId: false,
propertyNumberDisplayOption: PropertyNumberDisplayOption.Type.None,
keyValueSeparatorMark: ': ',
singleLineStartDelimiterMark: '{ ',
singleLineEndDelimiterMark: ' }',
multiLineStartDelimiterMark: '{',
multiLineEndDelimiterMark: '}',
prototypeStartDelimiterMark: '',
prototypeEndDelimiterMark: '@',
singleLineInBetweenPropertySeparatorMark: ', ',
multiLineInBetweenPropertySeparatorMark: ',',
idSeparatorMark: ' ',
propertyNumberSeparatorMark: ',',
propertyNumberStartDelimiterMark: '(',
propertyNumberEndDelimiterMark: ')',
propertySource: PropertySource.Type.FromProperties,
maxPrototypeDepth: 0,
propertyFilters: PPPropertyFilters.utilInspectLike,
propertySortOrder: /*#__PURE__*/_effect.Option.none(),
dedupeProperties: false,
maxPropertyNumber: 100,
propertyFormatter: PPPropertyFormatter.keyAndValue,
nonPrimitiveFormatter: /*#__PURE__*/PPNonPrimitiveFormatter.splitOnTotalLengthMaker(80)
});
/**
* NonPrimitive Option instance for arrays
*
* @category Instances
*/
NonPrimitive.array = /*#__PURE__*/NonPrimitive.make({
...NonPrimitive.record,
id: 'Array',
propertyNumberDisplayOption: PropertyNumberDisplayOption.Type.AllAndActualIfDifferent,
singleLineStartDelimiterMark: '[ ',
singleLineEndDelimiterMark: ' ]',
multiLineStartDelimiterMark: '[',
multiLineEndDelimiterMark: ']',
propertySource: PropertySource.Type.FromValueIterable,
propertyFilters: PPPropertyFilters.empty,
propertyFormatter: PPPropertyFormatter.valueOnly
});
/**
* Constructor that generates a NonPrimitive Option instance suitable for maps
*
* @category Constructors
*/
NonPrimitive.maps = id => NonPrimitive.make({
...NonPrimitive.record,
id,
showId: true,
propertyNumberDisplayOption: PropertyNumberDisplayOption.Type.AllAndActualIfDifferent,
keyValueSeparatorMark: ' => ',
propertySource: PropertySource.Type.FromKeyValueIterable,
propertyFilters: PPPropertyFilters.empty,
propertyFormatter: PPPropertyFormatter.keyAndValue
});
/**
* Constructor that generates a NonPrimitive Option instance suitable for sets and arrays other
* than Array
*
* @category Constructors
*/
NonPrimitive.setsAndArrays = id => NonPrimitive.make({
...NonPrimitive.record,
id,
showId: true,
propertyNumberDisplayOption: PropertyNumberDisplayOption.Type.AllAndActualIfDifferent,
propertySource: PropertySource.Type.FromValueIterable,
propertyFilters: PPPropertyFilters.empty,
propertyFormatter: PPPropertyFormatter.valueOnly
});
/**
* Namespace of an initialized NonPrimitive Option
*
* @category Models
*/
let Initialized;
(function (Initialized) {
/**
* Builds an Initialized from a NonPrimitive
*
* @category Constructors
*/
Initialized.fromNonPrimitive = params => {
const valueBasedStylerConstructor = params.valueBasedStylerConstructor;
const nonPrimitiveValueIdTextFormatter = valueBasedStylerConstructor('NonPrimitiveValueId');
const nonPrimitiveValueIdSeparatorTextFormatter = valueBasedStylerConstructor('NonPrimitiveValueIdSeparator');
const propertyNumberDelimitersTextFormatter = valueBasedStylerConstructor('PropertyNumberDelimiters');
const propertyNumberSeparatorTextFormatter = valueBasedStylerConstructor('PropertyNumberSeparator');
const PropertyNumbersTextFormatter = valueBasedStylerConstructor('PropertyNumbers');
return (0, _effect.flow)(_effectLib.MStruct.enrichWith({
syntheticPropertyFilter: nonPrimitiveOption => PPPropertyFilters.toSyntheticPropertyFilter(nonPrimitiveOption.propertyFilters),
initializedPropertyFormatter: nonPrimitiveOption => nonPrimitiveOption.propertyFormatter(params),
initializedNonPrimitiveFormatter: nonPrimitiveOption => nonPrimitiveOption.nonPrimitiveFormatter(params),
toHeaderMarkShower: nonPrimitiveOption => {
const emptyText = _effect.Function.constant(_ansiStyles.ASText.empty);
const propertyNumberDisplayOption = nonPrimitiveOption.propertyNumberDisplayOption;
const isNone = propertyNumberDisplayOption === PropertyNumberDisplayOption.Type.None;
const isAll = propertyNumberDisplayOption === PropertyNumberDisplayOption.Type.All;
const isActual = propertyNumberDisplayOption === PropertyNumberDisplayOption.Type.Actual;
const isAllAndActual = propertyNumberDisplayOption === PropertyNumberDisplayOption.Type.AllAndActual;
const isAllAndActualIfDifferent = propertyNumberDisplayOption === PropertyNumberDisplayOption.Type.AllAndActualIfDifferent;
const showId = nonPrimitiveOption.showId;
const [propertyNumberStartDelimiter, propertyNumberEndDelimiter] = isNone ? _effect.Tuple.make(emptyText, emptyText) : _effect.Tuple.make(propertyNumberDelimitersTextFormatter.withContextLast(nonPrimitiveOption.propertyNumberStartDelimiterMark), propertyNumberDelimitersTextFormatter.withContextLast(nonPrimitiveOption.propertyNumberEndDelimiterMark));
const propertyNumberSeparator = isAllAndActual || isAllAndActualIfDifferent ? propertyNumberSeparatorTextFormatter.withContextLast(nonPrimitiveOption.propertyNumberSeparatorMark) : emptyText;
const idSeparator = showId || !isNone ? nonPrimitiveValueIdSeparatorTextFormatter.withContextLast(nonPrimitiveOption.idSeparatorMark) : emptyText;
const id = showId ? nonPrimitiveValueIdTextFormatter.withContextLast(nonPrimitiveOption.id) : emptyText;
return ({
allPropertyNumber,
actualPropertyNumber
}) => value => {
const showAllAndActual = isAllAndActual || isAllAndActualIfDifferent && allPropertyNumber !== actualPropertyNumber;
const styledTotalPropertyNumber = isAll || showAllAndActual ? (0, _effect.pipe)(allPropertyNumber, _effectLib.MString.fromNonNullablePrimitive, PropertyNumbersTextFormatter.withContextLast, _effect.Function.apply(value)) : _ansiStyles.ASText.empty;
const styledActualPropertyNumber = isActual || showAllAndActual ? (0, _effect.pipe)(actualPropertyNumber, _effectLib.MString.fromNonNullablePrimitive, PropertyNumbersTextFormatter.withContextLast, _effect.Function.apply(value)) : _ansiStyles.ASText.empty;
const [inContextPropertyNumberStartDelimiter, inContextPropertyNumberSeparator, inContextPropertyNumberEndDelimiter, inContextIdSeparator] = isAllAndActualIfDifferent && allPropertyNumber === actualPropertyNumber ? [_ansiStyles.ASText.empty, _ansiStyles.ASText.empty, _ansiStyles.ASText.empty, showId ? idSeparator(value) : _ansiStyles.ASText.empty] : [propertyNumberStartDelimiter(value), propertyNumberSeparator(value), propertyNumberEndDelimiter(value), idSeparator(value)];
return _ansiStyles.ASText.concat(id(value), inContextPropertyNumberStartDelimiter, styledTotalPropertyNumber, inContextPropertyNumberSeparator, styledActualPropertyNumber, inContextPropertyNumberEndDelimiter, inContextIdSeparator);
};
}
}));
};
})(Initialized = NonPrimitive.Initialized || (NonPrimitive.Initialized = {}));
})(NonPrimitive || (exports.NonPrimitive = NonPrimitive = {}));
/**
* Type guard
*
* @category Guards
*/
const has = u => _effect.Predicate.hasProperty(u, _TypeId);
/**
* Equivalence
*
* @category Equivalences
*/
exports.has = has;
const equivalence = (self, that) => that.id === self.id;
/** Prototype */
exports.equivalence = equivalence;
const _TypeIdHash = /*#__PURE__*/_effect.Hash.hash(_TypeId);
const proto = {
[_TypeId]: _TypeId,
[_effect.Equal.symbol](that) {
return has(that) && equivalence(this, that);
},
[_effect.Hash.symbol]() {
return (0, _effect.pipe)(this.id, _effect.Hash.hash, _effect.Hash.combine(_TypeIdHash), _effect.Hash.cached(this));
},
[_effectLib.MInspectable.IdSymbol]() {
return this.id;
},
... /*#__PURE__*/_effectLib.MInspectable.BaseProto(moduleTag),
..._effectLib.MPipeable.BaseProto
};
/**
* Constructor without a id
*
* @category Constructors
*/
const make = params => _effectLib.MTypes.objectFromDataAndProto(proto, params);
/**
* Returns the `id` property of `self`
*
* @category Destructors
*/
exports.make = make;
const id = exports.id = /*#__PURE__*/_effect.Struct.get('id');
/**
* `Option` instance that pretty-prints a value in a way very similar to util.inspect.
*
* @category Instances
*/
const utilInspectLike = exports.utilInspectLike = /*#__PURE__*/make({
id: 'UtilInspectLike',
styleMap: PPStyleMap.none,
markMap: PPMarkMap.utilInspectLike,
byPassers: /*#__PURE__*/_effect.Array.make(PPByPasser.functionToName, PPByPasser.objectToString),
primitiveFormatter: /*#__PURE__*/PPPrimitiveFormatter.utilInspectLikeMaker(),
maxDepth: 2,
generalNonPrimitiveOption: NonPrimitive.record,
specificNonPrimitiveOption: value => {
const content = value.content;
if (_effectLib.MTypes.isArray(content)) return _effect.Option.some(NonPrimitive.array);
if (content instanceof Map) return _effect.Option.some(NonPrimitive.maps('Map'));
if (content instanceof Set) return _effect.Option.some(NonPrimitive.setsAndArrays('Set'));
if (content instanceof WeakMap) return _effect.Option.some(NonPrimitive.maps('WeakMap'));
if (content instanceof WeakSet) return _effect.Option.some(NonPrimitive.setsAndArrays('WeakSet'));
if (_effect.HashMap.isHashMap(content)) return _effect.Option.some(NonPrimitive.maps('EffectHashMap'));
if (_effect.SortedMap.isSortedMap(content)) return _effect.Option.some(NonPrimitive.maps('EffectSortedMap'));
if (_effect.HashSet.isHashSet(content)) return _effect.Option.some(NonPrimitive.setsAndArrays('EffectHashSet'));
if (_effect.SortedSet.isSortedSet(content)) return _effect.Option.some(NonPrimitive.setsAndArrays('EffectSortedSet'));
return (0, _effect.pipe)(content, _effectLib.MTypes.typedArrayName, _effect.Option.map(NonPrimitive.setsAndArrays));
}
});
/**
* `Option` instance that pretty-prints a value in a way very similar to util.inspect with colors
* adapted to a terminal in dark mode.
*
* @category Instances
*/
const darkModeUtilInspectLike = exports.darkModeUtilInspectLike = /*#__PURE__*/make({
...utilInspectLike,
id: 'DarkModeUtilInspectLike',
styleMap: PPStyleMap.darkMode
});
/**
* `Option` instance that treeifies a value
*
* @category Instances
*/
const treeify = exports.treeify = /*#__PURE__*/make({
id: 'Treeify',
styleMap: PPStyleMap.none,
markMap: PPMarkMap.utilInspectLike,
byPassers: /*#__PURE__*/_effect.Array.empty(),
primitiveFormatter: /*#__PURE__*/PPPrimitiveFormatter.utilInspectLikeMaker(),
maxDepth: +Infinity,
generalNonPrimitiveOption: /*#__PURE__*/NonPrimitive.make({
...NonPrimitive.record,
propertyFilters: /*#__PURE__*/_effect.Array.empty(),
propertySortOrder: /*#__PURE__*/_effect.Option.none(),
dedupeProperties: false,
maxPropertyNumber: +Infinity,
propertyFormatter: PPPropertyFormatter.treeify,
nonPrimitiveFormatter: PPNonPrimitiveFormatter.treeify
}),
specificNonPrimitiveOption: /*#__PURE__*/(0, _effect.flow)(utilInspectLike.specificNonPrimitiveOption, /*#__PURE__*/_effect.Option.map(/*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.set({
nonPrimitiveFormatter: PPNonPrimitiveFormatter.treeify,
propertyFormatter: PPPropertyFormatter.treeify
}), NonPrimitive.make)))
});
/**
* `Option` instance that treeifies a value with colors adapted to dark mode
*
* @category Instances
*/
const darkModeTreeify = exports.darkModeTreeify = /*#__PURE__*/make({
...treeify,
id: 'DarkModeTreeify',
styleMap: PPStyleMap.darkMode
});
/**
* `Option` instance that treeifies a value and hides the leaves
*
* @category Instances
*/
const treeifyHideLeaves = exports.treeifyHideLeaves = /*#__PURE__*/make({
...treeify,
id: 'TreeifyHideLeaves',
generalNonPrimitiveOption: /*#__PURE__*/NonPrimitive.make({
...treeify.generalNonPrimitiveOption,
propertyFormatter: PPPropertyFormatter.treeifyHideLeafValues
}),
specificNonPrimitiveOption: /*#__PURE__*/(0, _effect.flow)(treeify.specificNonPrimitiveOption, /*#__PURE__*/_effect.Option.map(/*#__PURE__*/(0, _effect.flow)(/*#__PURE__*/_effectLib.MStruct.set({
propertyFormatter: PPPropertyFormatter.treeifyHideLeafValues
}), NonPrimitive.make)))
});
/**
* `Option` instance that treeifies a value and hides the leaves with colors adapted to dark mode
*
* @category Instances
*/
const darkModeTreeifyHideLeaves = exports.darkModeTreeifyHideLeaves = /*#__PURE__*/make({
...treeifyHideLeaves,
id: 'DarkModeTreeifyHideLeaves',
styleMap: PPStyleMap.darkMode
});
/**
* Builds a Stringifier from an Option
*
* @category Destructors
*/
const toStringifier = self => {
const valueBasedStylerConstructor = PPValueBasedStylerConstructor.fromOption(self);
const markShowerConstructor = PPMarkShowerConstructor.fromOption(self);
const constructors = {
markShowerConstructor,
valueBasedStylerConstructor
};
const primitiveValueTextFormatter = valueBasedStylerConstructor('PrimitiveValue');
const messageTextFormatter = valueBasedStylerConstructor('Message');
const circularObjectMarkShower = markShowerConstructor('CircularObject');
const circularReferenceStartDelimiterMarkShower = markShowerConstructor('CircularReferenceStartDelimiter');
const circularReferenceEndDelimiterMarkShower = markShowerConstructor('CircularReferenceEndDelimiter');
const messageStartDelimiterMarkShower = markShowerConstructor('MessageStartDelimiter');
const messageEndDelimiterMarkShower = markShowerConstructor('MessageEndDelimiter');
const initializedByPasser = PPByPassers.toSyntheticByPasser(self.byPassers).call(self, constructors);
const toInitializedNonPrimitiveOption = NonPrimitive.Initialized.fromNonPrimitive(constructors);
const initializedNonPrimitiveOptionCache = _effectLib.MCache.make({
lookUp: ({
key
}) => _effect.Tuple.make(toInitializedNonPrimitiveOption(key), true)
});
const initializedNonPrimitiveOptionGetter = _effectLib.MCache.toGetter(initializedNonPrimitiveOptionCache);
const initializedGeneralNonPrimitiveOption = initializedNonPrimitiveOptionGetter(self.generalNonPrimitiveOption);
const functionToNameByPasser = PPByPasser.functionToName.call(self, constructors);
let lastCyclicalIndex = 1;
const cyclicalMap = _effect.MutableHashMap.empty();
const stringifier = (0, _effect.flow)(PPValue.fromTopValue, _effectLib.MTree.unfoldAndFold({
unfold: (seed, cyclicalRef) => (0, _effect.pipe)(_effect.Either.gen(function* () {
const notByPassed = yield* (0, _effect.pipe)(seed, initializedByPasser, _effect.Either.fromOption(_effect.Function.constant(seed)), _effect.Either.flip);
const unBypassedNonPrimitive = yield* (0, _effect.pipe)(notByPassed, _effect.Either.liftPredicate(PPValue.isNonPrimitive, _effect.Function.unsafeCoerce), _effect.Either.mapLeft((0, _effect.flow)(self.primitiveFormatter, primitiveValueTextFormatter(notByPassed), PPStringifiedValue.fromText)));
const initializedNonPrimitiveOption = (0, _effect.pipe)(unBypassedNonPrimitive, self.specificNonPrimitiveOption, _effect.Option.map(initializedNonPrimitiveOptionGetter), _effect.Option.getOrElse(_effect.Function.constant(initializedGeneralNonPrimitiveOption)));
const unBypassedNonPrimitiveUnderMaxDepth = yield* (0, _effect.pipe)(unBypassedNonPrimitive, _effect.Either.liftPredicate((0, _effect.flow)(PPValue.depth, _effect.Number.lessThan(self.maxDepth)), (0, _effect.flow)(functionToNameByPasser, _effect.Option.getOrElse((0, _effect.pipe)(initializedNonPrimitiveOption.id, messageTextFormatter(unBypassedNonPrimitive), _ansiStyles.ASText.surround(messageStartDelimiterMarkShower(unBypassedNonPrimitive), messageEndDelimiterMarkShower(unBypassedNonPrimitive)), PPStringifiedValue.fromText, _effect.Function.constant)))));
const unCyclicalUnBypassedNonPrimitiveUnderMaxDepth = yield* (0, _effect.pipe)(cyclicalRef, _effect.Option.map(([cyclicalValue]) => (0, _effect.pipe)(cyclicalMap, _effect.MutableHashMap.get(cyclicalValue), _effect.Option.getOrElse(() => {
/* eslint-disable-next-line functional/no-expression-statements */
_effect.MutableHashMap.set(cyclicalMap, cyclicalValue, lastCyclicalIndex);
return lastCyclicalIndex++;
}), _effectLib.MString.fromNonNullablePrimitive, messageTextFormatter(unBypassedNonPrimitiveUnderMaxDepth), _ansiStyles.ASText.prepend(circularObjectMarkShower(unBypassedNonPrimitiveUnderMaxDepth)), _ansiStyles.ASText.surround(messageStartDelimiterMarkShower(unBypassedNonPrimitiveUnderMaxDepth), messageEndDelimiterMarkShower(unBypassedNonPrimitiveUnderMaxDepth)), PPStringifiedValue.fromText)), _effect.Either.fromOption(_effect.Function.constant(unBypassedNonPrimitiveUnderMaxDepth)), _effect.Either.flip);
const properties = (0, _effect.pipe)(initializedNonPrimitiveOption.propertySource, _effectLib.MMatch.make, _effectLib.MMatch.whenIs(PropertySource.Type.FromProperties, (0, _effect.pipe)(initializedNonPrimitiveOption.maxPrototypeDepth, PPValues.fromProperties, _effect.Function.constant)), _effectLib.MMatch.whenIs(PropertySource.Type.FromValueIterable, _effect.Function.constant(PPValues.fromValueIterable)), _effectLib.MMatch.whenIs(PropertySource.Type.FromKeyValueIterable, _effect.Function.constant(PPValues.fromKeyValueIterable(stringifier))), _effectLib.MMatch.exhaustive, _effect.Function.apply(unCyclicalUnBypassedNonPrimitiveUnderMaxDepth));
const sort = (0, _effect.pipe)(initializedNonPrimitiveOption.propertySortOrder, _effect.Option.map(order => _effect.Array.sort(order)), _effect.Option.getOrElse(_effect.Function.constant(_effect.Function.identity)));
const filteredAndSortedProperties = (0, _effect.pipe)(properties, initializedNonPrimitiveOption.syntheticPropertyFilter, sort, _effectLib.MFunction.fIfTrue({
condition: initializedNonPrimitiveOption.dedupeProperties,
f: _effect.Array.dedupeWith((self, that) => self.oneLineStringKey === that.oneLineStringKey)
}), _effect.Array.take(initializedNonPrimitiveOption.maxPropertyNumber));
return _effect.Tuple.make(_effect.Tuple.make(unCyclicalUnBypassedNonPrimitiveUnderMaxDepth, initializedNonPrimitiveOption, properties.length), filteredAndSortedProperties);
}), _effect.Either.mapLeft((0, _effect.flow)(_effect.Tuple.make, _effect.Tuple.appendElement(seed), _effect.Tuple.appendElement(true)))),
foldNonLeaf: ([nonPrimitive, initializedNonPrimitiveOption, allPropertyNumber], children) => (0, _effect.pipe)(children, _effect.Array.map(([stringified, value, isLeaf]) => (0, _effect.pipe)(stringified, initializedNonPrimitiveOption.initializedPropertyFormatter({
value,
isLeaf
}))), initializedNonPrimitiveOption.initializedNonPrimitiveFormatter({
value: nonPrimitive,
header: (0, _effect.pipe)(cyclicalMap, _effect.MutableHashMap.get(nonPrimitive), _effect.Option.map((0, _effect.flow)(_effectLib.MString.fromNonNullablePrimitive, messageTextFormatter(nonPrimitive), _ansiStyles.ASText.prepend(circularReferenceStartDelimiterMarkShower(nonPrimitive)), _ansiStyles.ASText.append(circularReferenceEndDelimiterMarkShower(nonPrimitive)))), _effect.Option.getOrElse(_effect.Function.constant(_ansiStyles.ASText.empty)), _ansiStyles.ASText.append((0, _effect.pipe)(nonPrimitive, initializedNonPrimitiveOption.toHeaderMarkShower({
allPropertyNumber,
actualPropertyNumber: children.length
}))))
}), _effect.Tuple.make, _effect.Tuple.appendElement(nonPrimitive), _effect.Tuple.appendElement(false)),
foldLeaf: _effect.Function.identity
}), ([first]) => first);
return stringifier;
};
exports.toStringifier = toStringifier;
//# sourceMappingURL=Option.js.map