@adviser/cement 0.2.5 → 0.2.7

package/index.d.ts

@@ -32,6 +32,46 @@ declare class ResultError<T extends Error> extends Result<never, T> {
 }
 type WithoutResult<T> = T extends Result<infer U> ? U : T;
 
+type NullOrUndef = null | undefined;
+declare class BuildURI {
+    private _url;
+    constructor(url: URL);
+    hostname(h: string): this;
+    password(p: string): this;
+    port(p: string): this;
+    username(u: string): this;
+    search(s: string): this;
+    protocol(p: string): this;
+    pathname(p: string): this;
+    hash(h: string): this;
+    host(h: string): this;
+    delParam(key: string): this;
+    setParam(key: string, str: string): this;
+    toString(): string;
+    build(): URI;
+}
+type CoerceURI = string | URL | URI | NullOrUndef;
+declare class URI {
+    static from(strURLUri: CoerceURI, defaultProtocol?: string): URI;
+    readonly _url: URL;
+    private constructor();
+    build(): BuildURI;
+    get hostname(): string;
+    get password(): string;
+    get port(): string;
+    get username(): string;
+    get search(): string;
+    get protocol(): string;
+    get pathname(): string;
+    get hash(): string;
+    get host(): string;
+    hasParam(key: string): boolean;
+    getParam(key: string): string | undefined;
+    clone(): URI;
+    asURL(): URL;
+    toString(): string;
+}
+
 declare enum Level {
     WARN = "warn",
     DEBUG = "debug",
@@ -46,9 +86,17 @@ declare class LogValue {
     value(): Serialized;
     toJSON(): Serialized;
 }
-type LogSerializable = Record<string, LogValue>;
+type LogSerializable = Record<string, LogValue | Promise<LogValue>>;
 declare function removeSelfRef(): (key: unknown, val: unknown) => unknown;
+declare function asyncLogValue(val: () => Promise<Serialized>): Promise<LogValue>;
 declare function logValue(val: Serialized | FnSerialized | LogSerializable | undefined | null): LogValue;
+interface Sized {
+    size: number;
+}
+interface Lengthed {
+    length: number;
+}
+type SizeOrLength = Sized | Lengthed;
 interface LoggerInterface<R> {
     Module(key: string): R;
     EnableLevel(level: Level, ...modules: string[]): R;
@@ -58,10 +106,9 @@ interface LoggerInterface<R> {
         toString: () => string;
     } | FnSerialized): R;
     Result<T>(key: string, res: Result<T>): R;
-    Url(url: URL, key?: string): R;
-    Len(value: object | {
-        length: number;
-    } | string | undefined | null, key?: string): R;
+    Url(url: URL | URI | string, key?: string): R;
+    Len(value: unknown, key?: string): R;
+    Hash(value: unknown, key?: string): R;
     Str(key: string, value?: string): R;
     Error(): R;
     Warn(): R;
@@ -146,7 +193,8 @@ declare class LoggerImpl implements Logger {
     Bool(key: string, value: unknown): Logger;
     Result<T>(key: string, res: Result<T, Error>): Logger;
     Len(value: unknown, key?: string): Logger;
-    Url(url: URL, key?: string): Logger;
+    Hash(value: unknown, key?: string): Logger;
+    Url(url: URL | URI | string, key?: string): Logger;
     Str(key: string, value?: string): Logger;
     Any(key: string, value?: string | number | boolean | LogSerializable): Logger;
     Dur(key: string, nsec: number): Logger;
@@ -266,4 +314,86 @@ declare class KeyedResolvSeq<T, K = string> extends Keyed<ResolveSeq<T, K>, K> {
     constructor();
 }
 
-export { type AsError, type FnSerialized, Future, IsLogger, Keyed, KeyedResolvOnce, KeyedResolvSeq, Level, type LevelHandler, LevelHandlerImpl, LogCollector, type LogSerializable, LogValue, LogWriter$1 as LogWriter, type Logger, LoggerImpl, type LoggerImplParams, type LoggerInterface, MockLogger, type MockLoggerReturn, None, Option, ResolveOnce, ResolveSeq, Result, ResultError, ResultOK, type Serialized, Some, SysAbstraction, type WithLogger, type WithoutOption, type WithoutResult, logValue, removeSelfRef };
+interface Runtime {
+    isNodeIsh: boolean;
+    isBrowser: boolean;
+    isDeno: boolean;
+    isReactNative: boolean;
+}
+declare function runtimeFn(): Runtime;
+
+interface CTJsonWebKey {
+    alg?: string;
+    crv?: string;
+    d?: string;
+    dp?: string;
+    dq?: string;
+    e?: string;
+    ext?: boolean;
+    k?: string;
+    key_ops?: string[];
+    kty?: string;
+    n?: string;
+    oth?: RsaOtherPrimesInfo[];
+    p?: string;
+    q?: string;
+    qi?: string;
+    use?: string;
+    x?: string;
+    y?: string;
+}
+type CTKeyFormat = "jwk" | "pkcs8" | "raw" | "spki";
+type CTKeyUsage = "decrypt" | "deriveBits" | "deriveKey" | "encrypt" | "sign" | "unwrapKey" | "verify" | "wrapKey";
+interface CTAlgorithm {
+    name: string;
+}
+type CTAlgorithmIdentifier = CTAlgorithm | string;
+interface CTRsaHashedImportParams extends CTAlgorithm {
+    hash: CTAlgorithmIdentifier;
+}
+type CTNamedCurve = string;
+interface CTEcKeyImportParams extends CTAlgorithm {
+    namedCurve: CTNamedCurve;
+}
+interface CTHmacImportParams extends CTAlgorithm {
+    hash: CTAlgorithmIdentifier;
+    length?: number;
+}
+interface CTAesKeyAlgorithm extends CTAlgorithm {
+    length: number;
+}
+type CTKeyType = "private" | "public" | "secret";
+interface CTCryptoKey {
+    readonly algorithm: CTAlgorithm;
+    readonly extractable: boolean;
+    readonly type: CTKeyType;
+    readonly usages: CTKeyUsage[];
+}
+interface CTArrayBufferTypes {
+    ArrayBuffer: ArrayBuffer;
+}
+type CTArrayBufferLike = CTArrayBufferTypes[keyof CTArrayBufferTypes];
+interface CTArrayBufferView {
+    buffer: CTArrayBufferLike;
+    byteLength: number;
+    byteOffset: number;
+}
+type CTBufferSource = CTArrayBufferView | ArrayBuffer;
+interface CryptoRuntime {
+    importKey(format: CTKeyFormat, keyData: CTJsonWebKey | CTBufferSource, algorithm: CTAlgorithmIdentifier | CTRsaHashedImportParams | CTEcKeyImportParams | CTHmacImportParams | CTAesKeyAlgorithm, extractable: boolean, keyUsages: CTKeyUsage[]): Promise<CTCryptoKey>;
+    decrypt(algo: {
+        name: string;
+        iv: Uint8Array;
+        tagLength: number;
+    }, key: CTCryptoKey, data: Uint8Array): Promise<ArrayBuffer>;
+    encrypt(algo: {
+        name: string;
+        iv: Uint8Array;
+        tagLength: number;
+    }, key: CTCryptoKey, data: Uint8Array): Promise<ArrayBuffer>;
+    digestSHA256(data: Uint8Array): Promise<ArrayBuffer>;
+    randomBytes(size: number): Uint8Array;
+}
+declare function toCryptoRuntime(cryptoOpts?: Partial<CryptoRuntime>): CryptoRuntime;
+
+export { type AsError, BuildURI, type CTAesKeyAlgorithm, type CTAlgorithm, type CTAlgorithmIdentifier, type CTArrayBufferView, type CTBufferSource, type CTCryptoKey, type CTEcKeyImportParams, type CTHmacImportParams, type CTJsonWebKey, type CTKeyFormat, type CTKeyType, type CTKeyUsage, type CTNamedCurve, type CTRsaHashedImportParams, type CoerceURI, type CryptoRuntime, type FnSerialized, Future, IsLogger, Keyed, KeyedResolvOnce, KeyedResolvSeq, type Lengthed, Level, type LevelHandler, LevelHandlerImpl, LogCollector, type LogSerializable, LogValue, LogWriter$1 as LogWriter, type Logger, LoggerImpl, type LoggerImplParams, type LoggerInterface, MockLogger, type MockLoggerReturn, None, Option, ResolveOnce, ResolveSeq, Result, ResultError, ResultOK, type Runtime, type Serialized, type SizeOrLength, type Sized, Some, SysAbstraction, URI, type WithLogger, type WithoutOption, type WithoutResult, asyncLogValue, logValue, removeSelfRef, runtimeFn, toCryptoRuntime };

package/index.js

@@ -52,6 +52,9 @@ function removeSelfRef() {
     return value;
   };
 }
+function asyncLogValue(val) {
+  throw new Error("Not implemented");
+}
 function logValue(val) {
   switch (typeof val) {
     case "function":
@@ -208,6 +211,30 @@ var LogWriter = class {
     });
   }
 };
+function getLen(value) {
+  if (Array.isArray(value)) {
+    return logValue(() => value.length);
+  } else if (typeof value === "string") {
+    return logValue(() => value.length);
+  } else if (typeof value === "object" && value !== null) {
+    if (typeof value.size === "number") {
+      return logValue(() => value.size);
+    } else if (typeof value.length === "number") {
+      return logValue(() => value.length);
+    }
+    return logValue(() => Object.keys(value).length);
+  }
+  return logValue(() => -1);
+}
+function hash(value) {
+  return "not implemented";
+}
+function toLogValue(lop) {
+  if (lop && typeof lop.then === "function") {
+    throw new Error("async logValue Not implemented");
+  }
+  return lop;
+}
 var LoggerImpl = class _LoggerImpl {
   // readonly _id: string = "logger-" + Math.random().toString(36)
   constructor(params) {
@@ -317,15 +344,11 @@ var LoggerImpl = class _LoggerImpl {
     return this;
   }
   Len(value, key = "len") {
-    if (Array.isArray(value)) {
-      this._attributes[key] = logValue(() => value.length);
-    } else if (typeof value === "string") {
-      this._attributes[key] = logValue(() => value.length);
-    } else if (typeof value === "object" && value !== null) {
-      this._attributes[key] = logValue(() => Object.keys(value).length);
-    } else {
-      this.Int(key, -1);
-    }
+    this._attributes[key] = getLen(value);
+    return this;
+  }
+  Hash(value, key = "hash") {
+    this._attributes[key] = asyncLogValue(async () => `${getLen(value).value()}:${await hash(value)}`);
     return this;
   }
   Url(url, key = "url") {
@@ -383,7 +406,7 @@ var LoggerImpl = class _LoggerImpl {
     if (typeof msg === "string" && !msg.trim().length) {
       delete attr["msg"];
     }
-    if (((_a = attr["ts"]) == null ? void 0 : _a.value()) === "ETERNITY") {
+    if (((_a = toLogValue(attr["ts"])) == null ? void 0 : _a.value()) === "ETERNITY") {
       this.Timestamp.call({
         _sys: this._sys,
         _attributes: attr
@@ -394,7 +417,10 @@ var LoggerImpl = class _LoggerImpl {
   Msg(...args) {
     const fnError = this._resetAttributes(() => {
       var _a, _b;
-      const doWrite = this._levelHandler.isEnabled((_a = this._attributes["level"]) == null ? void 0 : _a.value(), (_b = this._attributes["module"]) == null ? void 0 : _b.value());
+      const doWrite = this._levelHandler.isEnabled(
+        (_a = toLogValue(this._attributes["level"])) == null ? void 0 : _a.value(),
+        (_b = toLogValue(this._attributes["module"])) == null ? void 0 : _b.value()
+      );
       let fnRet = () => this._produceError(__spreadValues({}, this._attributes), ...args);
       if (doWrite) {
         const str = fnRet();
@@ -441,6 +467,10 @@ var WithLoggerBuilder = class {
     this._li.Len(value, key);
     return this;
   }
+  Hash(value, key) {
+    this._li.Hash(value, key);
+    return this;
+  }
   Ref(key, action) {
     this._li.Ref(key, action);
     return this;
@@ -530,7 +560,9 @@ var LogWriter2 = class {
   releaseLock() {
   }
   write(chunk) {
-    chunk && this._bufferArr.push(chunk);
+    if (chunk) {
+      this._bufferArr.push(chunk);
+    }
     return Promise.resolve(void 0);
   }
 };
@@ -591,7 +623,9 @@ function MockLogger(params) {
     sys: params == null ? void 0 : params.sys,
     levelHandler: new LevelHandlerImpl()
   }).With().Module(modNames[0]).Logger();
-  !(params == null ? void 0 : params.disableDebug) && logger.SetDebug(...modNames);
+  if (!(params == null ? void 0 : params.disableDebug)) {
+    logger.SetDebug(...modNames);
+  }
   return {
     logCollector: lc,
     logger
@@ -719,8 +753,197 @@ var None = class extends Option {
     throw new Error("None.unwrap");
   }
 };
+
+// src/runtime.ts
+function isSet(value, ref = globalThis) {
+  const [head, ...tail] = value.split(".");
+  if (["object", "function"].includes(typeof ref) && ref && ["object", "function"].includes(typeof ref[head]) && ref[head]) {
+    if (tail.length <= 1) {
+      return true;
+    }
+    return isSet(tail.join("."), ref[head]);
+  }
+  return false;
+}
+function runtimeFn() {
+  const isNodeIsh = isSet("process.versions.node");
+  const isDeno = isSet("Deno");
+  return {
+    isNodeIsh,
+    isBrowser: !(isNodeIsh || isDeno),
+    isDeno,
+    isReactNative: false
+  };
+}
+
+// src/uri.ts
+function falsy2undef(value) {
+  return value === void 0 || value === null ? void 0 : value;
+}
+function ensureURLWithDefaultProto(url, defaultProtocol) {
+  if (!url) {
+    return new URL(`${defaultProtocol}//`);
+  }
+  if (typeof url === "string") {
+    try {
+      return new URL(url);
+    } catch (e) {
+      return new URL(`${defaultProtocol}//${url}`);
+    }
+  } else {
+    return url;
+  }
+}
+var BuildURI = class {
+  constructor(url) {
+    this._url = url;
+  }
+  hostname(h) {
+    this._url.hostname = h;
+    return this;
+  }
+  password(p) {
+    this._url.password = p;
+    return this;
+  }
+  port(p) {
+    this._url.port = p;
+    return this;
+  }
+  username(u) {
+    this._url.username = u;
+    return this;
+  }
+  search(s) {
+    this._url.search = s;
+    return this;
+  }
+  protocol(p) {
+    this._url.protocol = p;
+    return this;
+  }
+  pathname(p) {
+    this._url.pathname = p;
+    return this;
+  }
+  hash(h) {
+    this._url.hash = h;
+    return this;
+  }
+  host(h) {
+    this._url.host = h;
+    return this;
+  }
+  delParam(key) {
+    this._url.searchParams.delete(key);
+    return this;
+  }
+  setParam(key, str) {
+    this._url.searchParams.set(key, str);
+    return this;
+  }
+  toString() {
+    return this._url.toString();
+  }
+  build() {
+    return URI.from(this._url);
+  }
+};
+var URI = class _URI {
+  // if no protocol is provided, default to file:
+  static from(strURLUri, defaultProtocol = "file:") {
+    switch (typeof falsy2undef(strURLUri)) {
+      case "undefined":
+        return new _URI(new URL(`${defaultProtocol}//`));
+      case "string":
+        return new _URI(ensureURLWithDefaultProto(strURLUri, defaultProtocol));
+      case "object":
+        if (strURLUri instanceof _URI) {
+          return new _URI(new URL(strURLUri._url.toString()));
+        } else if (strURLUri instanceof URL) {
+          return new _URI(new URL(strURLUri.toString()));
+        }
+        throw new Error(`unknown object type: ${strURLUri}`);
+      default:
+        throw new Error(`Invalid argument: ${typeof strURLUri}`);
+    }
+  }
+  constructor(url) {
+    this._url = url;
+  }
+  build() {
+    return new BuildURI(this.asURL());
+  }
+  get hostname() {
+    return this._url.hostname;
+  }
+  get password() {
+    return this._url.password;
+  }
+  get port() {
+    return this._url.port;
+  }
+  get username() {
+    return this._url.username;
+  }
+  get search() {
+    return this._url.search;
+  }
+  get protocol() {
+    return this._url.protocol;
+  }
+  get pathname() {
+    return this._url.toString().replace(/^.*:\/\//, "").replace(/\?.*$/, "");
+  }
+  get hash() {
+    return this._url.hash;
+  }
+  get host() {
+    return this._url.host;
+  }
+  hasParam(key) {
+    return this._url.searchParams.has(key);
+  }
+  getParam(key) {
+    return falsy2undef(this._url.searchParams.get(key));
+  }
+  clone() {
+    return new _URI(this.asURL());
+  }
+  asURL() {
+    const url = new URL(this._url.toString());
+    url.searchParams.sort();
+    return url;
+  }
+  toString() {
+    return this._url.toString();
+  }
+};
+
+// src/crypto.ts
+function randomBytes(size) {
+  const bytes = new Uint8Array(size);
+  if (size > 0) {
+    crypto.getRandomValues(bytes);
+  }
+  return bytes;
+}
+function digestSHA256(data) {
+  return Promise.resolve(crypto.subtle.digest("SHA-256", data));
+}
+function toCryptoRuntime(cryptoOpts = {}) {
+  const runtime = {
+    importKey: cryptoOpts.importKey || crypto.subtle.importKey.bind(crypto.subtle),
+    encrypt: cryptoOpts.encrypt || crypto.subtle.encrypt.bind(crypto.subtle),
+    decrypt: cryptoOpts.decrypt || crypto.subtle.decrypt.bind(crypto.subtle),
+    randomBytes: cryptoOpts.randomBytes || randomBytes,
+    digestSHA256: cryptoOpts.digestSHA256 || digestSHA256
+  };
+  return runtime;
+}
 export {
   BrowserEnvActions,
+  BuildURI,
   EnvImpl,
   Future,
   IDMode,
@@ -748,8 +971,12 @@ export {
   Time,
   TimeMode,
   TimeUnits,
+  URI,
+  asyncLogValue,
   envFactory,
   logValue,
-  removeSelfRef
+  removeSelfRef,
+  runtimeFn,
+  toCryptoRuntime
 };
 //# sourceMappingURL=index.js.map