react-ternary-be-gone 0.1.0 → 0.1.1

package/.babelrc

@@ -0,0 +1,3 @@
+{
+  "presets": ["@babel/preset-env", "@babel/preset-react"]
+}

package/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: ["@babel/preset-env", "@babel/preset-react"]
+};

package/dist/Conditional.js

@@ -0,0 +1,206 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const Conditional = _ref => {
+  let {
+    when,
+    each,
+    children,
+    fallback = null,
+    empty = null,
+    loading = false,
+    error = null,
+    keyExtractor = (item, index) => index,
+    // New features
+    filter = null,
+    sort = null,
+    limit = null,
+    reverse = false,
+    animate = false,
+    wrapper = _react.default.Fragment,
+    debug = false,
+    onRender = null,
+    // Conditional rendering helpers
+    gt = null,
+    // greater than
+    lt = null,
+    // less than
+    eq = null,
+    // equal
+    ne = null,
+    // not equal
+    includes = null,
+    startsWith = null,
+    endsWith = null,
+    match = null // regex match
+  } = _ref;
+  const hasCondition = when !== undefined;
+  const hasIteration = each !== undefined;
+
+  // Advanced condition evaluation
+  const evaluateCondition = (0, _react.useMemo)(() => {
+    if (when !== undefined) return Boolean(when);
+
+    // Numerical comparisons
+    if (gt !== null && typeof gt === 'object') {
+      const {
+        value,
+        target
+      } = gt;
+      return value > target;
+    }
+    if (lt !== null && typeof lt === 'object') {
+      const {
+        value,
+        target
+      } = lt;
+      return value < target;
+    }
+    if (eq !== null && typeof eq === 'object') {
+      const {
+        value,
+        target
+      } = eq;
+      return value === target;
+    }
+    if (ne !== null && typeof ne === 'object') {
+      const {
+        value,
+        target
+      } = ne;
+      return value !== target;
+    }
+
+    // String operations
+    if (includes !== null && typeof includes === 'object') {
+      const {
+        value,
+        target
+      } = includes;
+      return String(value).includes(target);
+    }
+    if (startsWith !== null && typeof startsWith === 'object') {
+      const {
+        value,
+        target
+      } = startsWith;
+      return String(value).startsWith(target);
+    }
+    if (endsWith !== null && typeof endsWith === 'object') {
+      const {
+        value,
+        target
+      } = endsWith;
+      return String(value).endsWith(target);
+    }
+    if (match !== null && typeof match === 'object') {
+      const {
+        value,
+        pattern
+      } = match;
+      return new RegExp(pattern).test(String(value));
+    }
+    return true;
+  }, [when, gt, lt, eq, ne, includes, startsWith, endsWith, match]);
+
+  // Array processing
+  const processedArray = (0, _react.useMemo)(() => {
+    if (!hasIteration || !Array.isArray(each)) return [];
+    let result = [...each];
+
+    // Apply filter
+    if (filter && typeof filter === 'function') {
+      result = result.filter(filter);
+    }
+
+    // Apply sort
+    if (sort && typeof sort === 'function') {
+      result = result.sort(sort);
+    }
+
+    // Apply reverse
+    if (reverse) {
+      result = result.reverse();
+    }
+
+    // Apply limit
+    if (limit && typeof limit === 'number') {
+      result = result.slice(0, limit);
+    }
+    if (debug) {
+      console.log('Conditional Debug:', {
+        original: each,
+        processed: result,
+        filter: !!filter,
+        sort: !!sort,
+        reverse,
+        limit
+      });
+    }
+    return result;
+  }, [each, filter, sort, reverse, limit, hasIteration, debug]);
+
+  // Render callback
+  (0, _react.useEffect)(() => {
+    if (onRender && typeof onRender === 'function') {
+      onRender({
+        condition: evaluateCondition,
+        itemCount: processedArray.length,
+        hasCondition,
+        hasIteration
+      });
+    }
+  }, [evaluateCondition, processedArray.length, hasCondition, hasIteration, onRender]);
+
+  // Loading state
+  if (loading) {
+    return fallback || /*#__PURE__*/_react.default.createElement("div", {
+      className: "conditional-loading"
+    }, "Loading...");
+  }
+
+  // Error state
+  if (error) {
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: "conditional-error"
+    }, "Error: ", error);
+  }
+
+  // Wrapper component
+  const WrapperComponent = wrapper;
+
+  // Only condition
+  if (hasCondition && !hasIteration) {
+    return evaluateCondition ? /*#__PURE__*/_react.default.createElement(WrapperComponent, null, children) : fallback;
+  }
+
+  // Only iteration
+  if (!hasCondition && hasIteration) {
+    if (processedArray.length === 0) {
+      return empty || fallback;
+    }
+    const elements = processedArray.map((item, index) => /*#__PURE__*/_react.default.createElement(_react.default.Fragment, {
+      key: keyExtractor(item, index)
+    }, typeof children === 'function' ? children(item, index, processedArray) : children));
+    return animate ? /*#__PURE__*/_react.default.createElement(WrapperComponent, {
+      className: "conditional-animated"
+    }, elements) : /*#__PURE__*/_react.default.createElement(WrapperComponent, null, elements);
+  }
+
+  // Both condition and iteration
+  if (hasCondition && hasIteration) {
+    if (!evaluateCondition) return fallback;
+    if (processedArray.length === 0) return empty || fallback;
+    const elements = processedArray.map((item, index) => /*#__PURE__*/_react.default.createElement(_react.default.Fragment, {
+      key: keyExtractor(item, index)
+    }, children(item, index, processedArray)));
+    return /*#__PURE__*/_react.default.createElement(WrapperComponent, null, elements);
+  }
+  return /*#__PURE__*/_react.default.createElement(WrapperComponent, null, children);
+};
+var _default = exports.default = Conditional;

package/dist/babel.config.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = {
+  presets: ["@babel/preset-env", "@babel/preset-react"]
+};

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+Object.defineProperty(exports, "useConditionalHelpers", {
+  enumerable: true,
+  get: function () {
+    return _useConditionalHelpers.useConditionalHelpers;
+  }
+});
+var _Conditional = _interopRequireDefault(require("./Conditional"));
+var _useConditionalHelpers = require("./useConditionalHelpers");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = exports.default = _Conditional.default;

package/dist/useConditionalHelpers.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useConditionalHelpers = void 0;
+var _react = require("react");
+const useConditionalHelpers = () => {
+  return (0, _react.useMemo)(() => ({
+    // Quick condition helpers
+    isEmpty: array => ({
+      when: !array || array.length === 0
+    }),
+    isNotEmpty: array => ({
+      when: array && array.length > 0
+    }),
+    hasLength: (array, length) => ({
+      when: array && array.length === length
+    }),
+    isEven: num => ({
+      when: num % 2 === 0
+    }),
+    isOdd: num => ({
+      when: num % 2 !== 0
+    }),
+    // Array processing helpers
+    sortBy: function (field) {
+      let order = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'asc';
+      return (a, b) => {
+        const aValue = a[field];
+        const bValue = b[field];
+        if (aValue < bValue) {
+          return order === 'asc' ? -1 : 1;
+        }
+        if (aValue > bValue) {
+          return order === 'asc' ? 1 : -1;
+        }
+        return 0;
+      };
+    },
+    filterBy: (field, value) => item => item[field] === value,
+    unique: (array, key) => {
+      const seen = new Set();
+      return array.filter(item => {
+        const keyValue = typeof key === 'function' ? key(item) : item[key];
+        const isNew = !seen.has(keyValue);
+        seen.add(keyValue);
+        return isNew;
+      });
+    }
+  }), []);
+};
+exports.useConditionalHelpers = useConditionalHelpers;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "react-ternary-be-gone",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A React component designed to simplify conditional rendering and list iteration, providing a more readable and maintainable alternative to ternary operators and verbose conditional logic.",
-  "main": "index.js",
+  "main": "dist/index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "babel . --out-dir dist"
   },
   "peerDependencies": {
     "react": ">=16.8.0"
@@ -23,5 +24,9 @@
   "bugs": {
     "url": "https://github.com/sundowatch/react-ternary-be-gone/issues"
   },
-  "homepage": "https://github.com/sundowatch/react-ternary-be-gone#readme"
+  "homepage": "https://github.com/sundowatch/react-ternary-be-gone#readme",
+  "devDependencies": {
+    "@babel/cli": "^7.28.0",
+    "@babel/preset-react": "^7.27.1"
+  }
 }