@nlozgachev/pipelined 0.12.0 → 0.14.0

package/dist/index.mjs

@@ -0,0 +1,120 @@
+import {
+  and,
+  compose,
+  constFalse,
+  constNull,
+  constTrue,
+  constUndefined,
+  constVoid,
+  constant,
+  converge,
+  curry,
+  curry3,
+  curry4,
+  flip,
+  flow,
+  identity,
+  juxt,
+  memoize,
+  memoizeWeak,
+  not,
+  on,
+  once,
+  or,
+  pipe,
+  tap,
+  uncurry,
+  uncurry3,
+  uncurry4
+} from "./chunk-4TXC322E.mjs";
+import {
+  Lens,
+  Logged,
+  Optional,
+  Predicate,
+  Reader,
+  Refinement,
+  RemoteData,
+  State,
+  TaskOption,
+  TaskResult,
+  TaskValidation,
+  These,
+  Tuple,
+  Validation
+} from "./chunk-UV2HMF2A.mjs";
+import {
+  Arr,
+  Dict,
+  Num,
+  Rec,
+  Str,
+  Uniq
+} from "./chunk-FAZN3IWZ.mjs";
+import {
+  Deferred,
+  Option,
+  Result,
+  Task
+} from "./chunk-QPTGO5AS.mjs";
+import {
+  Brand
+} from "./chunk-BYWKZLHM.mjs";
+import {
+  isNonEmptyList
+} from "./chunk-DBIC62UV.mjs";
+export {
+  Arr,
+  Brand,
+  Deferred,
+  Dict,
+  Lens,
+  Logged,
+  Num,
+  Option,
+  Optional,
+  Predicate,
+  Reader,
+  Rec,
+  Refinement,
+  RemoteData,
+  Result,
+  State,
+  Str,
+  Task,
+  TaskOption,
+  TaskResult,
+  TaskValidation,
+  These,
+  Tuple,
+  Uniq,
+  Validation,
+  and,
+  compose,
+  constFalse,
+  constNull,
+  constTrue,
+  constUndefined,
+  constVoid,
+  constant,
+  converge,
+  curry,
+  curry3,
+  curry4,
+  flip,
+  flow,
+  identity,
+  isNonEmptyList,
+  juxt,
+  memoize,
+  memoizeWeak,
+  not,
+  on,
+  once,
+  or,
+  pipe,
+  tap,
+  uncurry,
+  uncurry3,
+  uncurry4
+};

package/dist/types.d.mts

@@ -0,0 +1,54 @@
+export { N as NonEmptyList, i as isNonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
+
+declare const _brand: unique symbol;
+/**
+ * Brand<K, T> creates a nominal type by tagging T with a phantom brand K.
+ * Prevents accidentally mixing up values that share the same underlying type.
+ *
+ * @example
+ * ```ts
+ * type UserId = Brand<"UserId", string>;
+ * type ProductId = Brand<"ProductId", string>;
+ *
+ * const toUserId = Brand.wrap<"UserId", string>();
+ * const toProductId = Brand.wrap<"ProductId", string>();
+ *
+ * const userId: UserId = toUserId("user-123");
+ * const productId: ProductId = toProductId("prod-456");
+ *
+ * // Type error: ProductId is not assignable to UserId
+ * // const wrong: UserId = productId;
+ * ```
+ */
+type Brand<K extends string, T> = T & {
+    readonly [_brand]: K;
+};
+declare namespace Brand {
+    /**
+     * Returns a constructor that wraps a value of type T in brand K.
+     * The resulting function performs an unchecked cast — only use when the raw
+     * value is known to satisfy the brand's invariants.
+     *
+     * @example
+     * ```ts
+     * type PositiveNumber = Brand<"PositiveNumber", number>;
+     * const toPositiveNumber = Brand.wrap<"PositiveNumber", number>();
+     *
+     * const n: PositiveNumber = toPositiveNumber(42);
+     * ```
+     */
+    const wrap: <K extends string, T>() => (value: T) => Brand<K, T>;
+    /**
+     * Strips the brand and returns the underlying value.
+     * Since Brand<K, T> extends T this is rarely needed, but can improve readability.
+     *
+     * @example
+     * ```ts
+     * const userId: UserId = toUserId("user-123");
+     * const raw: string = Brand.unwrap(userId); // "user-123"
+     * ```
+     */
+    const unwrap: <K extends string, T>(branded: Brand<K, T>) => T;
+}
+
+export { Brand };

package/{types/src/Types/Brand.d.ts → dist/types.d.ts}

@@ -1,3 +1,5 @@
+export { N as NonEmptyList, i as isNonEmptyList } from './NonEmptyList-BlGFjor5.js';
+
 declare const _brand: unique symbol;
 /**
  * Brand<K, T> creates a nominal type by tagging T with a phantom brand K.
@@ -18,10 +20,10 @@ declare const _brand: unique symbol;
  * // const wrong: UserId = productId;
  * ```
  */
-export type Brand<K extends string, T> = T & {
+type Brand<K extends string, T> = T & {
     readonly [_brand]: K;
 };
-export declare namespace Brand {
+declare namespace Brand {
     /**
      * Returns a constructor that wraps a value of type T in brand K.
      * The resulting function performs an unchecked cast — only use when the raw
@@ -48,5 +50,5 @@ export declare namespace Brand {
      */
     const unwrap: <K extends string, T>(branded: Brand<K, T>) => T;
 }
-export {};
-//# sourceMappingURL=Brand.d.ts.map
+
+export { Brand };

package/dist/types.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Types/index.ts
+var Types_exports = {};
+__export(Types_exports, {
+  Brand: () => Brand,
+  isNonEmptyList: () => isNonEmptyList
+});
+module.exports = __toCommonJS(Types_exports);
+
+// src/Types/Brand.ts
+var Brand;
+((Brand2) => {
+  Brand2.wrap = () => (value) => value;
+  Brand2.unwrap = (branded) => branded;
+})(Brand || (Brand = {}));
+
+// src/Types/NonEmptyList.ts
+var isNonEmptyList = (list) => list.length > 0;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Brand,
+  isNonEmptyList
+});

package/dist/types.mjs

@@ -0,0 +1,10 @@
+import {
+  Brand
+} from "./chunk-BYWKZLHM.mjs";
+import {
+  isNonEmptyList
+} from "./chunk-DBIC62UV.mjs";
+export {
+  Brand,
+  isNonEmptyList
+};