exupery-core-types 0.1.0

package/dist/Array.d.ts

@@ -0,0 +1,37 @@
+import { Async_Value } from "./Async_Value";
+import { Optional_Value } from "./Optional_Value";
+/**
+ * A Exupery array.
+ * unmutable and minimal by design
+ */
+export interface Array<T> {
+    /**
+     *
+     * @param $v callback to transform an individual entry.
+     */
+    map<NT>($v: ($: T) => NT): Array<NT>;
+    /**
+     * maps the array to {@link Async_Value} that contains an array
+     * @param $v callback that provides an async value. keys are not available.
+     */
+    async_map<NT>($v: ($: T) => Async_Value<NT>): Async_Value<Array<NT>>;
+    /**
+     * This method is only to be used by resources
+     * iterates over all entries
+     *
+     * @param $v callback to process the entry
+     */
+    __for_each($v: ($: T) => void): void;
+    /**
+     * This method is only to be used by resources
+     *
+     */
+    __get_length(): number;
+    /**
+     * This method is only to be used by resources
+     *
+     * @param index
+     */
+    __get_element_at(index: number): Optional_Value<T>;
+    __get_raw_copy(): readonly T[];
+}

package/dist/Array.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Async_Value.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A value that will asynchronously become available.
+ * Similar to the concept of a promise, but with a smaller API.
+ */
+export interface Async_Value<T> {
+    /**
+     * maps the current async value into a new async value
+     * @param $v callback that transforms the actual value into a new Async_Value
+     */
+    map<NT>($v: ($: T) => Async_Value<NT>): Async_Value<NT>;
+    /**
+     * This method is only to be used by resources
+     */
+    __execute($i: ($: T) => void): void;
+}

package/dist/Async_Value.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Computed_Value.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A computed value is a function without paramters returning the specified type
+ * it makes it possible to do the evaluation only when the function is called
+ * useful for lazy evaluation or when side effects are needed
+ */
+export type Computed_Value<T> = () => T;

package/dist/Computed_Value.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Dictionary.d.ts

@@ -0,0 +1,39 @@
+import { Array } from "./Array";
+import { Async_Value } from "./Async_Value";
+import { Optional_Value } from "./Optional_Value";
+export type Key_Value_Pair<T> = {
+    readonly 'key': string;
+    readonly 'value': T;
+};
+export type Compare_Function<T> = (a: Key_Value_Pair<T>, b: Key_Value_Pair<T>) => number;
+/**
+ * A Exupery dictionary.
+ * unmutable and minimal by design
+ */
+export interface Dictionary<T> {
+    /**
+     *
+     * @param $v callback to transform an individual entry. keys are not available.
+     */
+    map<NT>($v: ($: T, key: string) => NT): Dictionary<NT>;
+    /**
+     *
+     * @param $v callback that provides an {@link Async_Value}. keys are not available.
+     */
+    async_map<NT>($v: ($: T) => Async_Value<NT>): Async_Value<Dictionary<NT>>;
+    /**
+     * This method is only to be used by resources
+     * iterates over all entries in a sorted manner
+     */
+    to_array(compare: Compare_Function<T>): Array<Key_Value_Pair<T>>;
+    /**
+     * This method is only to be used by resources
+     * returns an {@link Optional_Value } of type T reflecting wether the entry existed or not
+     *
+     * @param key
+     */
+    __get_entry(key: string): Optional_Value<T>;
+    __add_entry_if_not_exists(key: string, value: T): Dictionary<T>;
+    __add_entry_overwrite_if_exists(key: string, value: T): Dictionary<T>;
+    __remove_entry_if_exists(key: string): Dictionary<T>;
+}

package/dist/Dictionary.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Lookup.d.ts

@@ -0,0 +1,14 @@
+import { Optional_Value } from "./Optional_Value";
+/**
+ * A lookup is similar to a Dictionary, but much more basic.
+ * There are only operations to retrieve entries
+ */
+export interface Lookup<T> {
+    /**
+     * This method is only to be used by resources
+     * returns an {@link Optional_Value } of type T reflecting wether the entry existed or not
+     *
+     * @param key
+     */
+    __get_entry(key: string): Optional_Value<T>;
+}

package/dist/Lookup.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Optional_Value.d.ts

@@ -0,0 +1,25 @@
+/**
+ * this is literal data type, either [false] or [true, T]
+ * the first entry of the tuple is thus 'false' or 'true'. If the first one is 'true',
+ * then there is a second one containing the value T
+ */
+export type Raw_Optional_Value<T> = readonly [false] | readonly [true, T];
+/**
+ * Why this type and not use for example 'null | T'?
+ * the 'null | T' is vulnerable. If you have a parametrized function 'foo<T>() null | T' and T is null | number,
+ * you cannot discern if a return value is null because of the function or because of the data
+ * this 'Optional_Value' type makes it possible to have recursive optional types like this: Optional_Value<Optional_Value<number>>
+ */
+export interface Optional_Value<T> {
+    /**
+     * @param set what to do when the value was set, returns the new type
+     * @param not_set  what to do when the value was not set, returns the new type
+     */
+    transform<NT>(set: ($: T) => NT, not_set: () => NT): NT;
+    /**
+     *
+     */
+    map<NT>(//this one should be called 'map'
+    set: ($: T) => NT): Optional_Value<NT>;
+    __raw: Raw_Optional_Value<T>;
+}

package/dist/Optional_Value.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/globals.d.ts

@@ -0,0 +1,20 @@
+interface Array<T> {
+}
+interface Boolean {
+}
+interface CallableFunction {
+}
+interface Function {
+}
+interface IArguments {
+}
+interface NewableFunction {
+}
+interface Number {
+}
+interface Object {
+}
+interface RegExp {
+}
+interface String {
+}

package/dist/globals.js

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

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./Array";
+export * from "./Async_Value";
+export * from "./Computed_Value";
+export * from "./Dictionary";
+export * from "./Lookup";
+export * from "./Optional_Value";

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Array"), exports);
+__exportStar(require("./Async_Value"), exports);
+__exportStar(require("./Computed_Value"), exports);
+__exportStar(require("./Dictionary"), exports);
+__exportStar(require("./Lookup"), exports);
+__exportStar(require("./Optional_Value"), exports);

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "exupery-core-types",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "author": "Corno",
+  "description": "core types for Exupery",
+  "keywords": [
+    "exupery",
+    "type system",
+    "Dictionary",
+    "Array",
+    "Async_Value",
+    "Optional_Value",
+    "Nested",
+    "Computed_Value"
+  ],
+  "homepage": "https://github.com/corno/exupery-core#readme",
+  "bugs": {
+    "url": "https://github.com/corno/exupery-core/issues"
+  },
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/corno/exupery-core.git"
+  }
+}