@tstdl/base 0.86.0-beta1 → 0.86.0-beta10

package/serializer/serializer.js

@@ -1,272 +1,292 @@
-/* eslint-disable @typescript-eslint/no-unsafe-return, @typescript-eslint/ban-types, max-lines-per-function, max-statements, complexity */
-import { CircularBuffer } from '../data-structures/circular-buffer.js';
-import { SortedArrayList } from '../data-structures/sorted-array-list.js';
-import { compareByValueSelection } from '../utils/comparison.js';
-import { ForwardRef } from '../utils/object/forward-ref.js';
-import { objectEntries } from '../utils/object/object.js';
-import { isDefined, isUndefined } from '../utils/type-guards.js';
-import { getSerializerByTypeName, getTypeNameByConstructor, isRawSerializable } from './serializable.js';
-import { bigintNonPrimitiveType, functionNonPrimitiveType, globalSymbolNonPrimitiveType, rawNonPrimitiveType, refNonPrimitiveType, undefinedNonPrimitiveType } from './types.js';
-export function stringSerialize(value, options) {
-    const serialized = serialize(value, options);
-    return JSON.stringify(serialized);
+"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);
+var serializer_exports = {};
+__export(serializer_exports, {
+  deserialize: () => deserialize,
+  serialize: () => serialize,
+  stringDeserialize: () => stringDeserialize,
+  stringSerialize: () => stringSerialize
+});
+module.exports = __toCommonJS(serializer_exports);
+var import_circular_buffer = require("../data-structures/circular-buffer.js");
+var import_sorted_array_list = require("../data-structures/sorted-array-list.js");
+var import_comparison = require("../utils/comparison.js");
+var import_forward_ref = require("../utils/object/forward-ref.js");
+var import_object = require("../utils/object/object.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_serializable = require("./serializable.js");
+var import_types = require("./types.js");
+function stringSerialize(value, options) {
+  const serialized2 = serialize(value, options);
+  return JSON.stringify(serialized2);
 }
-export function stringDeserialize(serialized, options) {
-    const parsedStringSerialized = JSON.parse(serialized);
-    return deserialize(parsedStringSerialized, options);
+function stringDeserialize(serialized2, options) {
+  const parsedStringSerialized = JSON.parse(serialized2);
+  return deserialize(parsedStringSerialized, options);
 }
-export function serialize(_value, options = {}, references = new Map(), queue = new CircularBuffer(), path = '$') {
-    let value = _value;
-    if (isDefined(options.replacers)) {
-        for (const replacer of options.replacers) {
-            value = replacer(value);
-        }
-    }
-    const type = typeof value;
-    if (type == 'boolean' || type == 'number' || value === null) {
-        return value;
+function serialize(_value, options = {}, references = /* @__PURE__ */ new Map(), queue = new import_circular_buffer.CircularBuffer(), path2 = "$") {
+  let value = _value;
+  if ((0, import_type_guards.isDefined)(options.replacers)) {
+    for (const replacer of options.replacers) {
+      value = replacer(value);
     }
-    if (type == 'undefined') {
-        return { '<undefined>': null };
+  }
+  const type2 = typeof value;
+  if (type2 == "boolean" || type2 == "number" || value === null) {
+    return value;
+  }
+  if (type2 == "undefined") {
+    return { "<undefined>": null };
+  }
+  if (path2 == "$" && (0, import_type_guards.isDefined)(options.context)) {
+    for (const entry of (0, import_object.objectEntries)(options.context)) {
+      references.set(entry[1], `$['__context__']['${entry[0]}']`);
     }
-    if ((path == '$') && isDefined(options.context)) {
-        for (const entry of objectEntries(options.context)) {
-            references.set(entry[1], `$['__context__']['${entry[0]}']`);
-        }
+  }
+  const reference = references.get(value);
+  if ((0, import_type_guards.isDefined)(reference)) {
+    return { "<ref>": reference };
+  }
+  if (type2 == "string") {
+    if (value.length > path2.length + 50) {
+      references.set(value, path2);
     }
-    const reference = references.get(value);
-    if (isDefined(reference)) {
-        return { '<ref>': reference };
+    return value;
+  }
+  if (type2 == "bigint") {
+    const stringValue = value.toString(10);
+    if (stringValue.length > path2.length + 50) {
+      references.set(value, path2);
     }
-    if (type == 'string') {
-        if (value.length > (path.length + 50)) {
-            references.set(value, path);
-        }
-        return value;
+    return { "<bigint>": stringValue };
+  }
+  if (type2 == "symbol") {
+    const key = Symbol.keyFor(value);
+    if (key === void 0) {
+      throw new Error("only global symbols from Symbol.for(<key>) are supported");
     }
-    if (type == 'bigint') {
-        const stringValue = value.toString(10);
-        if (stringValue.length > (path.length + 50)) {
-            references.set(value, path);
-        }
-        return { '<bigint>': stringValue };
+    return { "<global-symbol>": key };
+  }
+  if (type2 == "function") {
+    if (options.allowUnsafe !== true) {
+      throw new Error("functions are only allowed if allowUnsafe option is true");
     }
-    if (type == 'symbol') {
-        const key = Symbol.keyFor(value);
-        if (key === undefined) {
-            throw new Error('only global symbols from Symbol.for(<key>) are supported');
-        }
-        return { '<global-symbol>': key };
+    references.set(value, path2);
+    const source = value.toString();
+    return { "<function>": source };
+  }
+  if (type2 == "object") {
+    let result2;
+    references.set(value, path2);
+    const constructor2 = value.constructor;
+    if (constructor2 == Array) {
+      const target = [];
+      target.length = value.length;
+      const queueItems = value.map((innerValue, index) => () => target[index] = serialize(innerValue, options, references, queue, `${path2}[${index}]`));
+      queue.addMany(queueItems);
+      result2 = target;
+    } else if (constructor2 == Object) {
+      const target = {};
+      const entries2 = (0, import_object.objectEntries)(value);
+      const queueItems = entries2.map(([key, innerValue]) => () => target[key] = serialize(innerValue, options, references, queue, `${path2}['${key.toString()}']`));
+      queue.addMany(queueItems);
+      result2 = target;
+    } else if ((0, import_serializable.isRawSerializable)(constructor2) || (0, import_type_guards.isDefined)(options.raws) && options.raws.includes(constructor2)) {
+      references.set(value, path2);
+      return { "<raw>": value };
+    } else {
+      const serializableType = (0, import_serializable.getTypeNameByConstructor)(constructor2);
+      if ((0, import_type_guards.isUndefined)(serializableType)) {
+        throw new Error(`constructor ${constructor2.name} has no serializer registered`);
+      }
+      const registration = (0, import_serializable.getSerializerByTypeName)(serializableType);
+      const typeString = getTypeString(serializableType);
+      const nonPrimitive = { [typeString]: null };
+      queue.add(() => {
+        const data = registration.serializer.call(value, value, options.data ?? {});
+        nonPrimitive[typeString] = registration.serializeData != false ? serialize(data, options, references, queue, `${path2}['${typeString}']`) : data;
+      });
+      result2 = nonPrimitive;
     }
-    if (type == 'function') {
-        if (options.allowUnsafe !== true) {
-            throw new Error('functions are only allowed if allowUnsafe option is true');
-        }
-        references.set(value, path);
-        const source = value.toString();
-        return { '<function>': source };
-    }
-    if (type == 'object') { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-        let result;
-        references.set(value, path);
-        const constructor = value.constructor;
-        if (constructor == Array) {
-            const target = [];
-            target.length = value.length;
-            const queueItems = value.map((innerValue, index) => () => (target[index] = serialize(innerValue, options, references, queue, `${path}[${index}]`)));
-            queue.addMany(queueItems);
-            result = target;
-        }
-        else if (constructor == Object) {
-            const target = {};
-            const entries = objectEntries(value);
-            const queueItems = entries.map(([key, innerValue]) => () => (target[key] = serialize(innerValue, options, references, queue, `${path}['${key.toString()}']`)));
-            queue.addMany(queueItems);
-            result = target;
-        }
-        else if (isRawSerializable(constructor) || (isDefined(options.raws) && options.raws.includes(constructor))) {
-            references.set(value, path);
-            return { '<raw>': value };
-        }
-        else {
-            const serializableType = getTypeNameByConstructor(constructor);
-            if (isUndefined(serializableType)) {
-                throw new Error(`constructor ${constructor.name} has no serializer registered`);
-            }
-            const registration = getSerializerByTypeName(serializableType);
-            const typeString = getTypeString(serializableType);
-            const nonPrimitive = { [typeString]: null };
-            queue.add(() => {
-                const data = registration.serializer.call(value, value, options.data ?? {});
-                (nonPrimitive[typeString] = (registration.serializeData != false) ? serialize(data, options, references, queue, `${path}['${typeString}']`) : data);
-            });
-            result = nonPrimitive;
-        }
-        if (path == '$') {
-            for (const fn of queue.consume()) {
-                fn();
-            }
-        }
-        return result;
+    if (path2 == "$") {
+      for (const fn2 of queue.consume()) {
+        fn2();
+      }
     }
-    throw new Error(`Unsupported type '${type}'.`);
+    return result2;
+  }
+  throw new Error(`Unsupported type '${type2}'.`);
 }
-export function deserialize(serialized, options) {
-    const context = getDeserializeContext(serialized, options);
-    return _deserialize(serialized, context, '$', 0);
+function deserialize(serialized2, options) {
+  const context2 = getDeserializeContext(serialized2, options);
+  return _deserialize(serialized2, context2, "$", 0);
 }
 function _deserialize(serialized, context, path, depth) {
-    const type = typeof serialized;
-    if ((type == 'number') || (type == 'boolean') || (serialized === null)) {
-        return serialized;
-    }
-    if (type == 'string') {
-        context.references.set(path, serialized);
-        return serialized;
+  const type = typeof serialized;
+  if (type == "number" || type == "boolean" || serialized === null) {
+    return serialized;
+  }
+  if (type == "string") {
+    context.references.set(path, serialized);
+    return serialized;
+  }
+  if (type == "undefined") {
+    return { "<undefined>": null };
+  }
+  if (type == "object") {
+    if (depth == 0 && (0, import_type_guards.isDefined)(context.options.context)) {
+      for (const entry of (0, import_object.objectEntries)(context.options.context)) {
+        context.references.set(`$['__context__']['${entry[0]}']`, entry[1]);
+      }
     }
-    if (type == 'undefined') {
-        return { '<undefined>': null };
-    }
-    if (type == 'object') {
-        if ((depth == 0) && isDefined(context.options.context)) {
-            for (const entry of objectEntries(context.options.context)) {
-                context.references.set(`$['__context__']['${entry[0]}']`, entry[1]);
-            }
+    const entries = (0, import_object.objectEntries)(serialized);
+    const isNonPrimitive = entries.length == 1 && entries[0][0].startsWith("<") && entries[0][0].endsWith(">");
+    if (isNonPrimitive) {
+      const nonPrimitiveData = entries[0][1];
+      const nonPrimitiveType = entries[0][0].slice(1, -1);
+      switch (nonPrimitiveType) {
+        case import_types.undefinedNonPrimitiveType: {
+          return void 0;
+        }
+        case import_types.bigintNonPrimitiveType: {
+          const bigint = BigInt(nonPrimitiveData);
+          context.references.set(path, bigint);
+          return bigint;
         }
-        const entries = objectEntries(serialized);
-        const isNonPrimitive = (entries.length == 1) && entries[0][0].startsWith('<') && entries[0][0].endsWith('>');
-        if (isNonPrimitive) {
-            const nonPrimitiveData = entries[0][1];
-            const nonPrimitiveType = entries[0][0].slice(1, -1);
-            switch (nonPrimitiveType) {
-                case undefinedNonPrimitiveType: {
-                    return undefined;
-                }
-                case bigintNonPrimitiveType: {
-                    const bigint = BigInt(nonPrimitiveData);
-                    context.references.set(path, bigint);
-                    return bigint;
-                }
-                case globalSymbolNonPrimitiveType: {
-                    const symbol = Symbol.for(nonPrimitiveData);
-                    context.references.set(path, symbol);
-                    return symbol;
-                }
-                case functionNonPrimitiveType: {
-                    if (context.options.allowUnsafe !== true) {
-                        throw new Error('functions are only allowed if allowUnsafe option is true');
-                    }
-                    const fn = eval(nonPrimitiveData); // eslint-disable-line no-eval
-                    context.references.set(path, fn);
-                    return fn;
-                }
-                case rawNonPrimitiveType: {
-                    return nonPrimitiveData;
-                }
-                case refNonPrimitiveType: {
-                    const dereferenced = context.references.get(nonPrimitiveData);
-                    if (dereferenced == undefined) {
-                        throw new Error(`reference ${nonPrimitiveData} not found`);
-                    }
-                    return dereferenced;
-                }
-                default: {
-                    const registration = getSerializerByTypeName(nonPrimitiveType);
-                    if (registration == undefined) {
-                        throw new Error(`non-primitive type ${nonPrimitiveType} not registered`);
-                    }
-                    const forwardRef = ForwardRef.create();
-                    context.references.set(path, forwardRef);
-                    context.addToDeserializeQueue(() => {
-                        const deserializedData = _deserialize(nonPrimitiveData, context, `${path}['<${nonPrimitiveType}>']`, depth + 1);
-                        context.addToDeserializeQueue(() => {
-                            const deserialized = registration.deserializer(deserializedData, context.tryAddToDerefQueue, context.options.data ?? {});
-                            ForwardRef.setRef(forwardRef, deserialized);
-                        }, depth);
-                    }, depth);
-                    if (depth == 0) {
-                        drainQueues(context);
-                        return ForwardRef.deref(forwardRef);
-                    }
-                    return forwardRef;
-                }
-            }
+        case import_types.globalSymbolNonPrimitiveType: {
+          const symbol = Symbol.for(nonPrimitiveData);
+          context.references.set(path, symbol);
+          return symbol;
         }
-        let result;
-        const constructor = serialized.constructor;
-        if (constructor == Array) {
-            const deserializedArray = [];
-            deserializedArray.length = serialized.length;
-            context.references.set(path, deserializedArray);
-            const queueItems = serialized.map((innerValue, index) => () => {
-                const deserialized = _deserialize(innerValue, context, `${path}[${index}]`, depth + 1);
-                deserializedArray[index] = deserialized;
-                context.tryAddToDerefQueue(deserialized, (dereferenced) => (deserializedArray[index] = dereferenced));
-                return deserialized;
-            });
-            context.addManyToDeserializeQueue(queueItems, depth);
-            result = deserializedArray;
+        case import_types.functionNonPrimitiveType: {
+          if (context.options.allowUnsafe !== true) {
+            throw new Error("functions are only allowed if allowUnsafe option is true");
+          }
+          const fn = eval(nonPrimitiveData);
+          context.references.set(path, fn);
+          return fn;
         }
-        else if (constructor == Object) {
-            const deserializedObject = {};
-            context.references.set(path, deserializedObject);
-            const queueItems = entries.map(([key, innerValue]) => () => {
-                const deserialized = _deserialize(innerValue, context, `${path}['${key}']`, depth + 1);
-                deserializedObject[key] = deserialized;
-                context.tryAddToDerefQueue(deserialized, (dereferenced) => (deserializedObject[key] = dereferenced));
-                return deserialized;
-            });
-            context.addManyToDeserializeQueue(queueItems, depth);
-            result = deserializedObject;
+        case import_types.rawNonPrimitiveType: {
+          return nonPrimitiveData;
         }
-        else {
-            throw new Error(`Unsupported constructor ${constructor.name}.`);
+        case import_types.refNonPrimitiveType: {
+          const dereferenced = context.references.get(nonPrimitiveData);
+          if (dereferenced == void 0) {
+            throw new Error(`reference ${nonPrimitiveData} not found`);
+          }
+          return dereferenced;
         }
-        if (depth == 0) {
+        default: {
+          const registration = (0, import_serializable.getSerializerByTypeName)(nonPrimitiveType);
+          if (registration == void 0) {
+            throw new Error(`non-primitive type ${nonPrimitiveType} not registered`);
+          }
+          const forwardRef = import_forward_ref.ForwardRef.create();
+          context.references.set(path, forwardRef);
+          context.addToDeserializeQueue(() => {
+            const deserializedData = _deserialize(nonPrimitiveData, context, `${path}['<${nonPrimitiveType}>']`, depth + 1);
+            context.addToDeserializeQueue(() => {
+              const deserialized = registration.deserializer(deserializedData, context.tryAddToDerefQueue, context.options.data ?? {});
+              import_forward_ref.ForwardRef.setRef(forwardRef, deserialized);
+            }, depth);
+          }, depth);
+          if (depth == 0) {
             drainQueues(context);
+            return import_forward_ref.ForwardRef.deref(forwardRef);
+          }
+          return forwardRef;
         }
-        return result;
+      }
+    }
+    let result;
+    const constructor = serialized.constructor;
+    if (constructor == Array) {
+      const deserializedArray = [];
+      deserializedArray.length = serialized.length;
+      context.references.set(path, deserializedArray);
+      const queueItems = serialized.map((innerValue, index) => () => {
+        const deserialized = _deserialize(innerValue, context, `${path}[${index}]`, depth + 1);
+        deserializedArray[index] = deserialized;
+        context.tryAddToDerefQueue(deserialized, (dereferenced) => deserializedArray[index] = dereferenced);
+        return deserialized;
+      });
+      context.addManyToDeserializeQueue(queueItems, depth);
+      result = deserializedArray;
+    } else if (constructor == Object) {
+      const deserializedObject = {};
+      context.references.set(path, deserializedObject);
+      const queueItems = entries.map(([key, innerValue]) => () => {
+        const deserialized = _deserialize(innerValue, context, `${path}['${key}']`, depth + 1);
+        deserializedObject[key] = deserialized;
+        context.tryAddToDerefQueue(deserialized, (dereferenced) => deserializedObject[key] = dereferenced);
+        return deserialized;
+      });
+      context.addManyToDeserializeQueue(queueItems, depth);
+      result = deserializedObject;
+    } else {
+      throw new Error(`Unsupported constructor ${constructor.name}.`);
     }
-    throw new Error(`Unsupported type '${type}'.`);
+    if (depth == 0) {
+      drainQueues(context);
+    }
+    return result;
+  }
+  throw new Error(`Unsupported type '${type}'.`);
 }
-function getTypeString(type) {
-    return `<${type}>`;
+function getTypeString(type2) {
+  return `<${type2}>`;
 }
 function getDeserializeContext(serializedRoot, options) {
-    const context = {
-        serializedRoot,
-        options: options ?? {},
-        references: new Map(),
-        deserializeCounter: 0,
-        deserializeQueue: new SortedArrayList(undefined, compareByValueSelection((item) => item.depth, (item) => item.counter)),
-        derefQueue: new CircularBuffer(),
-        addToDeserializeQueue(fn, depth) {
-            context.deserializeQueue.add({ depth, counter: context.deserializeCounter++, fn });
-        },
-        addManyToDeserializeQueue(fns, depth) {
-            for (const fn of fns) {
-                context.deserializeQueue.add({ depth, counter: context.deserializeCounter++, fn });
-            }
-        },
-        tryAddToDerefQueue(value, callback) {
-            if (!ForwardRef.isForwardRef(value) || (context.options.doNotDereferenceForwardRefs == true)) {
-                return false;
-            }
-            context.derefQueue.add(() => {
-                const dereferenced = ForwardRef.deref(value);
-                callback(dereferenced);
-            });
-            return true;
-        }
-    };
-    return context;
+  const context2 = {
+    serializedRoot,
+    options: options ?? {},
+    references: /* @__PURE__ */ new Map(),
+    deserializeCounter: 0,
+    deserializeQueue: new import_sorted_array_list.SortedArrayList(void 0, (0, import_comparison.compareByValueSelection)((item) => item.depth, (item) => item.counter)),
+    derefQueue: new import_circular_buffer.CircularBuffer(),
+    addToDeserializeQueue(fn2, depth2) {
+      context2.deserializeQueue.add({ depth: depth2, counter: context2.deserializeCounter++, fn: fn2 });
+    },
+    addManyToDeserializeQueue(fns, depth2) {
+      for (const fn2 of fns) {
+        context2.deserializeQueue.add({ depth: depth2, counter: context2.deserializeCounter++, fn: fn2 });
+      }
+    },
+    tryAddToDerefQueue(value, callback) {
+      if (!import_forward_ref.ForwardRef.isForwardRef(value) || context2.options.doNotDereferenceForwardRefs == true) {
+        return false;
+      }
+      context2.derefQueue.add(() => {
+        const dereferenced = import_forward_ref.ForwardRef.deref(value);
+        callback(dereferenced);
+      });
+      return true;
+    }
+  };
+  return context2;
 }
 function drainQueues({ deserializeQueue, derefQueue }) {
-    while (deserializeQueue.size > 0) {
-        const item = deserializeQueue.removeLast();
-        item.fn();
-    }
-    for (const fn of derefQueue.consume()) {
-        fn();
-    }
+  while (deserializeQueue.size > 0) {
+    const item = deserializeQueue.removeLast();
+    item.fn();
+  }
+  for (const fn2 of derefQueue.consume()) {
+    fn2();
+  }
 }

package/serializer/types.js

@@ -1,6 +1,34 @@
-export const rawNonPrimitiveType = 'raw';
-export const undefinedNonPrimitiveType = 'undefined';
-export const bigintNonPrimitiveType = 'bigint';
-export const globalSymbolNonPrimitiveType = 'global-symbol';
-export const functionNonPrimitiveType = 'function';
-export const refNonPrimitiveType = 'ref';
+"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);
+var types_exports = {};
+__export(types_exports, {
+  bigintNonPrimitiveType: () => bigintNonPrimitiveType,
+  functionNonPrimitiveType: () => functionNonPrimitiveType,
+  globalSymbolNonPrimitiveType: () => globalSymbolNonPrimitiveType,
+  rawNonPrimitiveType: () => rawNonPrimitiveType,
+  refNonPrimitiveType: () => refNonPrimitiveType,
+  undefinedNonPrimitiveType: () => undefinedNonPrimitiveType
+});
+module.exports = __toCommonJS(types_exports);
+const rawNonPrimitiveType = "raw";
+const undefinedNonPrimitiveType = "undefined";
+const bigintNonPrimitiveType = "bigint";
+const globalSymbolNonPrimitiveType = "global-symbol";
+const functionNonPrimitiveType = "function";
+const refNonPrimitiveType = "ref";

package/signals/api.d.ts

@@ -1,5 +1,5 @@
 import type * as Types from './implementation/index.js';
-export type { CreateComputedOptions, CreateEffectOptions, CreateSignalOptions, EffectCleanupRegisterFn, EffectRef, Signal, WritableSignal } from './implementation/index.js';
+export type { CreateComputedOptions, CreateEffectOptions, CreateSignalOptions, EffectCleanupRegisterFn, EffectRef, Signal, ToSignalOptions, WritableSignal } from './implementation/index.js';
 export type SignalsConfiguration = {
     signal: typeof Types.signal;
     computed: typeof Types.computed;

package/signals/api.js

@@ -1,18 +1,49 @@
-/* eslint-disable import/no-mutable-exports */
-export let signal;
-export let computed;
-export let effect;
-export let untracked;
-export let isSignal;
-export let toSignal;
-export let toObservable;
-/* eslint-enable import/no-mutable-exports */
-export function configureSignals(configuration) {
-    signal = configuration.signal;
-    computed = configuration.computed;
-    effect = configuration.effect;
-    untracked = configuration.untracked;
-    isSignal = configuration.isSignal;
-    toSignal = configuration.toSignal;
-    toObservable = configuration.toObservable;
+"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);
+var api_exports = {};
+__export(api_exports, {
+  computed: () => computed,
+  configureSignals: () => configureSignals,
+  effect: () => effect,
+  isSignal: () => isSignal,
+  signal: () => signal,
+  toObservable: () => toObservable,
+  toSignal: () => toSignal,
+  untracked: () => untracked
+});
+module.exports = __toCommonJS(api_exports);
+let signal = throwSignalsNotConfigured;
+let computed = throwSignalsNotConfigured;
+let effect = throwSignalsNotConfigured;
+let untracked = throwSignalsNotConfigured;
+let isSignal = throwSignalsNotConfigured;
+let toSignal = throwSignalsNotConfigured;
+let toObservable = throwSignalsNotConfigured;
+function configureSignals(configuration) {
+  signal = configuration.signal;
+  computed = configuration.computed;
+  effect = configuration.effect;
+  untracked = configuration.untracked;
+  isSignal = configuration.isSignal;
+  toSignal = configuration.toSignal;
+  toObservable = configuration.toObservable;
+}
+function throwSignalsNotConfigured() {
+  throw new Error("Signals are not configured. Use configureDefaultSignalsImplementation() for default implementation or configureSignals() for custom implementation.");
 }