@kaumlaut/pure 0.1.7 → 0.1.8

package/dist/effect/Fetch.d.ts

@@ -1,6 +1,6 @@
-import type { Guard } from '../guard/Guard';
-import type { Message } from '../runtime/Runtime';
-import { type Effect, type ReceiveEffectResult } from './Effect';
+import { ReceiveEffectResult, Effect } from '.';
+import type { Guard } from '../guard';
+import type { Message } from '../runtime';
 type HttpError = {
     code: number;
     message: string;

package/dist/effect/Fetch.js

@@ -1,5 +1,5 @@
-import { err, ok } from '../result/Result';
-import { effectWithName } from './Effect';
+import { effectWithName } from '.';
+import { err, ok } from '../result';
 export function isNotFound(error) {
     return isHttp(error) && error.code === 404;
 }

package/dist/effect/None.d.ts

@@ -1,2 +1,2 @@
-import { type Effect } from './Effect';
+import { type Effect } from '.';
 export declare function none(): Effect<any>;

package/dist/effect/None.js

@@ -1,4 +1,4 @@
-import { effectWithName } from './Effect';
+import { effectWithName } from '.';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function none() {
     return effectWithName('none', () => {

package/dist/effect/index.d.ts

@@ -1,4 +1,16 @@
-export * from "./Effect";
 export * from "./Fetch";
 export * from "./None";
-export type { Effect, AsyncEffect, AsyncNullEffect, EffectType, NullEffect, ReceiveEffectResult, SyncEffect } from "./Effect";
+import type { Result } from '../result';
+import type { Message } from '../runtime';
+export type AsyncEffect<T extends Message> = () => Promise<T>;
+export type SyncEffect<T extends Message> = () => T;
+export type NullEffect = () => null;
+export type AsyncNullEffect = () => Promise<null>;
+export type EffectType<T extends Message> = AsyncEffect<T> | SyncEffect<T> | NullEffect | AsyncNullEffect;
+export type Effect<T extends Message> = {
+    effectType: EffectType<T>;
+    name: string;
+    meta: object | null;
+};
+export declare function effectWithName<T extends Message>(name: string, effect: EffectType<T>, meta?: object | null): Effect<T>;
+export type ReceiveEffectResult<T, E, R> = (result: Result<T, E>) => R;

package/dist/effect/index.js

@@ -1,3 +1,9 @@
-export * from "./Effect";
 export * from "./Fetch";
 export * from "./None";
+export function effectWithName(name, effect, meta = null) {
+    return {
+        name,
+        effectType: effect,
+        meta,
+    };
+}

package/dist/guard/index.d.ts

@@ -1,2 +1 @@
-export * from "./Guard";
-export type { Guard } from "./Guard";
+export type Guard<T> = (value: unknown) => value is T;

package/dist/guard/index.js

@@ -1 +1 @@
-export * from "./Guard";
+export {};

package/dist/maybe/index.d.ts

@@ -1,2 +1,16 @@
-export * from "./Maybe";
-export type { Just, Maybe, Nothing } from "./Maybe";
+export type Just<T> = {
+    type: 'maybe-just';
+    value: T;
+};
+export type Nothing = {
+    type: 'maybe-nothing';
+};
+export type Maybe<T> = Just<T> | Nothing;
+export declare function nothing(): Nothing;
+export declare function just<T>(value: T): Just<T>;
+export declare function isNothing<T>(maybe: Maybe<T>): maybe is Nothing;
+export declare function isJust<T>(maybe: Maybe<T>): maybe is Just<T>;
+export declare function isMaybe<T>(value: unknown): value is Maybe<T>;
+export declare function mapMaybe<T, R>(maybe: Maybe<T>, func: (value: T) => R): Maybe<R>;
+export declare function filterMaybe<T>(maybe: Maybe<T>, func: (value: T) => boolean): Maybe<T>;
+export declare function maybeWithDefault<T>(maybe: Maybe<T>, defaultValue: T): T;

package/dist/maybe/index.js

@@ -1 +1,39 @@
-export * from "./Maybe";
+export function nothing() {
+    return {
+        type: 'maybe-nothing',
+    };
+}
+export function just(value) {
+    return {
+        type: 'maybe-just',
+        value,
+    };
+}
+export function isNothing(maybe) {
+    return maybe.type === 'maybe-nothing';
+}
+export function isJust(maybe) {
+    return maybe.type === 'maybe-just';
+}
+export function isMaybe(value) {
+    //@ts-expect-error is validated
+    return value.type === 'maybe-just' || value.type === 'maybe-nothing';
+}
+export function mapMaybe(maybe, func) {
+    if (isJust(maybe)) {
+        return just(func(maybe.value));
+    }
+    return maybe;
+}
+export function filterMaybe(maybe, func) {
+    if (isJust(maybe) && func(maybe.value)) {
+        return maybe;
+    }
+    return nothing();
+}
+export function maybeWithDefault(maybe, defaultValue) {
+    if (isJust(maybe)) {
+        return maybe.value;
+    }
+    return defaultValue;
+}

package/dist/parse/index.d.ts

@@ -1 +1,3 @@
-export * from "./Parse";
+import { type Result } from '../result';
+export declare function asInt(value: string): Result<number, string>;
+export declare function asFloat(value: string): Result<number, string>;

package/dist/parse/index.js

@@ -1 +1,15 @@
-export * from "./Parse";
+import { err, ok } from '../result';
+export function asInt(value) {
+    const parsed = parseInt(value, 10);
+    if (Number.isNaN(parsed)) {
+        return err('Number is NaN');
+    }
+    return ok(parsed);
+}
+export function asFloat(value) {
+    const parsed = parseFloat(value);
+    if (Number.isNaN(parsed)) {
+        return err('Number is NaN');
+    }
+    return ok(parsed);
+}

package/dist/result/index.d.ts

@@ -1,2 +1,16 @@
-export * from "./Result";
-export type { Err, Ok, Result } from "./Result";
+export type Ok<T> = {
+    type: 'ok-result';
+    value: T;
+};
+export type Err<T> = {
+    type: 'error-result';
+    error: T;
+};
+export type Result<T, E> = Ok<T> | Err<E>;
+export declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
+export declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
+export declare function ok<T>(value: T): Ok<T>;
+export declare function err<E>(error: E): Err<E>;
+export declare function map<T, E, R>(result: Result<T, E>, func: (value: T) => R): Result<R, E>;
+export declare function mapErr<T, E, R>(result: Result<T, E>, func: (value: E) => R): Result<T, R>;
+export declare function withDefault<T, E>(result: Result<T, E>, defaultValue: T): T;

package/dist/result/index.js

@@ -1 +1,36 @@
-export * from "./Result";
+export function isOk(result) {
+    return result.type === 'ok-result';
+}
+export function isErr(result) {
+    return result.type === 'error-result';
+}
+export function ok(value) {
+    return {
+        type: 'ok-result',
+        value,
+    };
+}
+export function err(error) {
+    return {
+        type: 'error-result',
+        error,
+    };
+}
+export function map(result, func) {
+    if (isOk(result)) {
+        return ok(func(result.value));
+    }
+    return result;
+}
+export function mapErr(result, func) {
+    if (isErr(result)) {
+        return err(func(result.error));
+    }
+    return result;
+}
+export function withDefault(result, defaultValue) {
+    if (isErr(result)) {
+        return defaultValue;
+    }
+    return result.value;
+}

package/dist/runtime/index.d.ts

@@ -1,3 +1,19 @@
-export * from "./Runtime";
+import type { Effect } from '../effect';
 export * from "./persistence";
-export type { Change, Changes, Init, Message, Update } from "./Runtime";
+export type Message<N extends string = string, T = any> = {
+    value: T;
+    name: N;
+};
+export type Update<Model, CustomMessage extends Message> = (model: Model, msg: CustomMessage) => [Model, Effect<CustomMessage>];
+export type Init<Model, CustomMessage extends Message> = () => [Model, Effect<CustomMessage>];
+export type Change<CustomMessage extends Message, Model> = [
+    CustomMessage | null,
+    model: Model,
+    effect: {
+        name: string;
+        meta: object | null;
+    } | null
+];
+export type Changes<CustomMessage extends Message, Model> = Change<CustomMessage, Model>[];
+export declare function is<CustomMessage extends Message<A>, A extends string>(name: A, message: Message): message is CustomMessage;
+export declare function create<MN extends string, T>(name: MN, value: T): Message<MN, T>;

package/dist/runtime/index.js

@@ -1,2 +1,10 @@
-export * from "./Runtime";
 export * from "./persistence";
+export function is(name, message) {
+    return message.name === name;
+}
+export function create(name, value) {
+    return {
+        name,
+        value
+    };
+}

package/dist/runtime/persistence/LocalStorage.d.ts

@@ -1,3 +1,3 @@
-import type { Message } from '../Runtime';
-import type { Persistence } from './Persistence';
+import type { Message } from '..';
+import type { Persistence } from '.';
 export declare const localStoragePersistence: <Model, CustomMessage extends Message>(name: string) => Persistence<Model, CustomMessage>;

package/dist/runtime/persistence/LocalStorage.js

@@ -1,4 +1,4 @@
-import { err, ok } from '../../result/Result';
+import { err, ok } from '../../result';
 export const localStoragePersistence = (name) => ({
     persist(model) {
         window.localStorage.setItem(name, btoa(JSON.stringify(model)));

package/dist/runtime/persistence/None.d.ts

@@ -1,3 +1,3 @@
-import type { Message } from '../Runtime';
-import type { Persistence } from './Persistence';
+import type { Message } from '..';
+import type { Persistence } from '.';
 export declare const noPersistence: <Model, CustomMessage extends Message>() => Persistence<Model, CustomMessage>;

package/dist/runtime/persistence/None.js

@@ -1,4 +1,4 @@
-import { ok } from '../../result/Result';
+import { ok } from '../../result';
 export const noPersistence = () => ({
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     persist(model) { },

package/dist/runtime/persistence/Persistence.d.ts

@@ -1,4 +1,4 @@
-import type { Guard } from '../../guard/Guard';
+import type { Guard } from '../../guard';
 import type { Result } from '../../result/Result';
 import type { Init, Message } from '../Runtime';
 export type Persistence<Model, CustomMessage extends Message> = {

package/dist/runtime/persistence/index.d.ts

@@ -1,3 +1,9 @@
+import { Guard } from "../../guard";
+import { Result } from "../../result";
+import { Message, Init } from "..";
 export * from "./LocalStorage";
 export * from "./None";
-export type { Persistence } from "./Persistence";
+export type Persistence<Model, CustomMessage extends Message> = {
+    persist(model: Model): void;
+    read(guard: Guard<Model>, init: Init<Model, CustomMessage>): Result<Model, string>;
+};

package/package.json

@@ -1,48 +1,33 @@
 {
   "name": "@kaumlaut/pure",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Types and functions for state management inspired by Elm and functional programming",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/index.js",
+  "markdown": "standard",
+  "readme": "docs/README.md",
   "scripts": {
     "build": "tsc",
     "test": "vitest",
+    "typedoc": "typedoc",
     "release": "npm run build && npm publish --access public"
   },
   "files": [
     "dist"
   ],
   "exports": {
-    "./effect": {
-      "import": "./dist/effect/index.js",
-      "types": "./dist/effect/index.d.ts"
-    },
-    "./result": {
-      "import": "./dist/result/index.js",
-      "types": "./dist/result/index.d.ts"
-    },
-    "./runtime": {
-      "import": "./dist/runtime/index.js",
-      "types": "./dist/runtime/index.d.ts"
-    },
-    "./maybe": {
-      "import": "./dist/maybe/index.js",
-      "types": "./dist/maybe/index.d.ts"
-    },
-    "./guard": {
-      "import": "./dist/guard/index.js",
-      "types": "./dist/guard/index.d.ts"
-    },
-    "./parse": {
-      "import": "./dist/parse/index.js",
-      "types": "./dist/parse/index.d.ts"
+    "./*": {
+      "import": "./dist/*/index.js",
+      "types": "./dist/*/index.d.ts"
     }
   },
   "type": "module",
   "author": "Max Kaemmerer",
   "license": "MIT",
   "devDependencies": {
+    "typedoc": "^0.27.9",
+    "typedoc-plugin-markdown": "^4.4.2",
     "typescript": "^5.8.2",
     "vitest": "^3.0.8"
   }