@adviser/cement 0.4.32 → 0.4.34

package/src/cli/patch-version-cmd.ts

@@ -72,6 +72,7 @@ export function generateVersionTsCmd(): ReturnType<typeof command> {
         type: string,
         description: "Path to the file containing the version, defaults to './src/version.ts'.",
       }),
+
       tsconfig: option({
         long: "tsconfig",
         short: "t",
@@ -145,7 +146,7 @@ function setupDenoJson(packageJsonFile: string, jsrJsonFile: string): void {
   const packageJson = JSON.parse(fs.readFileSync(packageJsonFile).toString()) as { dependencies: Record<string, string> };
   const jsrJson = JSON.parse(fs.readFileSync(jsrJsonFile).toString()) as { imports: Record<string, string> };
   jsrJson.imports = Object.fromEntries(
-    Array.from(Object.entries(packageJson.dependencies)).map(([k, v]) => [k, `npm:${k}@${v.replace(/^npm:/, "")}`]),
+    Array.from(Object.entries(packageJson.dependencies ?? {})).map(([k, v]) => [k, `npm:${k}@${v.replace(/^npm:/, "")}`]),
   );
   fs.writeFileSync(jsrJsonFile, JSON.stringify(jsrJson, undefined, 2) + "\n");
 }
@@ -181,7 +182,7 @@ export function setUpDenoJsonCmd(): ReturnType<typeof command> {
   });
 }
 
-export async function preparePubdir(pubdir: string, version: string): Promise<void> {
+export async function preparePubdir(pubdir: string, version: string, baseDir: string, srcDir: string): Promise<void> {
   // Set shell options equivalent to 'set -ex'
   $.verbose = true;
 
@@ -195,7 +196,7 @@ export async function preparePubdir(pubdir: string, version: string): Promise<vo
   await $`mkdir -p ${pubdir}`;
 
   // Copy files to pubdir
-  await $`cp -pr ../.gitignore ../README.md ../LICENSE ./dist/ts/ ${pubdir}/`;
+  await $`cp -pr ${path.join(baseDir, ".gitignore")} ${path.join(baseDir, "README.md")} ${path.join(baseDir, "LICENSE")} ./dist/ts/ ${pubdir}/`;
 
   // Copy from dist/pkg
   cd("dist/pkg");
@@ -203,8 +204,8 @@ export async function preparePubdir(pubdir: string, version: string): Promise<vo
   cd("../..");
 
   // Copy from src
-  cd("src");
-  await $`cp -pr . ../${pubdir}/src/`;
+  cd(srcDir);
+  await $`cp -pr . ../${pubdir}/${srcDir}/`;
   cd("..");
 
   // Rename .js files to .cjs in pubdir/cjs
@@ -231,20 +232,20 @@ export async function preparePubdir(pubdir: string, version: string): Promise<vo
   await $`cp package.json ${pubdir}/`;
 
   // Clean up test files in pubdir/src
-  cd(`${pubdir}/src`);
+  cd(`${pubdir}/${srcDir}`);
   await $`rm -f test/test-exit-handler.* ./utils/stream-test-helper.ts`.catch(() => {
     // Ignore errors if files don't exist
   });
   cd("../..");
 
   // Remove __screenshots__ directories
-  const screenshotDirs = await glob(`${pubdir}/src/**/__screenshots__`);
+  const screenshotDirs = await glob(`${pubdir}/${srcDir}/**/__screenshots__`);
   for (const dir of screenshotDirs) {
     await $`rm -rf ${dir}`;
   }
 
   // Remove test files
-  const testFiles = await glob(`${pubdir}/src/**/*.test.ts`);
+  const testFiles = await glob(`${pubdir}/${srcDir}/**/*.test.ts`);
   for (const file of testFiles) {
     await $`rm -f ${file}`;
   }
@@ -280,6 +281,22 @@ export function preparePubdirCmd(): ReturnType<typeof command> {
         type: string,
         description: "Path to the pubdir, defaults to './pubdir'.",
       }),
+      srcDir: option({
+        long: "srcDir",
+        short: "s",
+        defaultValue: () => "src",
+        defaultValueIsSerializable: true,
+        type: string,
+        description: "Path to the src directory, defaults to './src'.",
+      }),
+      baseDir: option({
+        long: "baseDir",
+        short: "b",
+        defaultValue: () => "../",
+        defaultValueIsSerializable: true,
+        type: string,
+        description: "Path to the base directory of the project, defaults to '../'.",
+      }),
       version: option({
         long: "version",
         short: "v",
@@ -290,7 +307,7 @@ export function preparePubdirCmd(): ReturnType<typeof command> {
       }),
     },
     handler: async (args) => {
-      await preparePubdir(args.pubdir, args.version);
+      await preparePubdir(args.pubdir, args.version, args.baseDir, args.srcDir);
     },
   });
 }

package/src/index.ts

@@ -27,6 +27,7 @@ export * from "./coerce-binary.js";
 export * from "./is-promise.js";
 export * from "./app-context.js";
 export * from "./load-asset.js";
+export * from "./mutable-url.js";
 
 // ugly
 export * as utils from "./utils/index.js";

package/src/load-asset.ts

@@ -2,7 +2,7 @@ import { pathOps } from "./path-ops.js";
 import { Result, exception2Result } from "./result.js";
 import { runtimeFn } from "./runtime.js";
 import { TxtEnDecoderSingleton } from "./txt-en-decoder.js";
-import { CoerceURI, URI } from "./uri.js";
+import { BuildURI, CoerceURI, URI } from "./uri.js";
 
 interface MockLoadAsset {
   fetch: typeof globalThis.fetch;
@@ -95,25 +95,26 @@ async function loadAssetReal(
     }
     return Result.Err(`cannot load file: ${baseUrl.url.toString()} from ${baseUrl.src}`);
   }
+  const urlToFetch = BuildURI.from(baseUrl.url);
   switch (baseUrl.src) {
     case "opts.fallBackUrl":
-      baseUrl.url.pathname = opts.pathCleaner(baseUrl.url.pathname, localPath, "fallback");
+      urlToFetch.pathname(opts.pathCleaner(baseUrl.url.pathname, localPath, "fallback"));
       break;
     case "import.meta.url":
-      baseUrl.url.pathname = opts.pathCleaner(baseUrl.url.pathname, localPath, "normal");
+      urlToFetch.pathname(opts.pathCleaner(baseUrl.url.pathname, localPath, "normal"));
       break;
   }
 
   const rRes = await exception2Result(() => {
-    if (!baseUrl.url) {
+    if (!urlToFetch) {
       throw Error(`base url not found from ${baseUrl.src}`);
     }
-    return callFetch(opts.mock)(baseUrl.url);
+    return callFetch(opts.mock)(urlToFetch.asURL());
   });
   if (rRes.isErr()) {
     if (baseUrl.src === "import.meta.url") {
       // eslint-disable-next-line no-console
-      console.warn(`fetch failed for: ${baseUrl.url}`);
+      console.warn(`fetch failed for: ${urlToFetch.toString()}`);
       return loadAssetReal(fallBackBaseUrl(opts), localPath, opts);
     }
     return Result.Err(rRes);

package/src/logger.ts

@@ -4,8 +4,9 @@ import { bin2string } from "./bin2text.js";
 import { Option } from "./option.js";
 import { Result } from "./result.js";
 import { TxtEnDecoder, TxtEnDecoderSingleton } from "./txt-en-decoder.js";
-import { CoerceURI, MutableURL } from "./uri.js";
+import { CoerceURI } from "./uri.js";
 import { isJSON } from "./is-json.js";
+import { ReadonlyURL } from "./mutable-url.js";
 
 export const Level = {
   WARN: "warn",
@@ -85,7 +86,7 @@ function logValueInternal(val: LogValueArg, ctx: LogValueStateInternal): LogValu
           return logValueInternal(ret, ctx);
         }
       }
-      const resIsURI = MutableURL.from(val);
+      const resIsURI = ReadonlyURL.from(val);
       if (resIsURI.isOk()) {
         return new LogValue(() => resIsURI.Ok().toString());
       }

package/src/mutable-url.ts

@@ -0,0 +1,365 @@
+import { exception2Result, Result } from "./result.js";
+import { hasHostPartProtocols } from "./uri.js";
+
+// due to that the System URL class is has a strange behavior
+// on different platforms, we need to implement our own URL class
+const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+
+const urlRegex = /^([a-z][a-z0-9_-]*):\/\/[^:]*$/i;
+
+// there are deno which does not have URLSearchParams.entries() in types
+export function* URLSearchParamsEntries(src: URLSearchParams): IterableIterator<[string, string]> {
+  const entries: [string, string][] = [];
+  src.forEach((v, k) => {
+    entries.push([k, v]);
+  });
+  for (const [key, value] of entries) {
+    yield [key, value];
+  }
+}
+
+export class ReadonlyURL extends URL {
+  protected readonly _sysURL: URL;
+  // private readonly _urlStr: string;
+
+  protected _protocol: string;
+  protected _pathname: string;
+  protected _hasHostpart: boolean;
+
+  static readonly fromThrow = (urlStr: string): ReadonlyURL => {
+    return new ReadonlyURL(urlStr);
+  };
+
+  static from(urlStr: string): Result<ReadonlyURL> {
+    if (urlRegex.test(urlStr)) {
+      return exception2Result(() => new ReadonlyURL(urlStr));
+    }
+    return Result.Err(`Invalid URL: ${urlStr}`);
+  }
+
+  protected constructor(urlStr: string) {
+    super("defect://does.not.exist");
+    const partedURL = urlStr.split(":");
+    this._hasHostpart = hasHostPartProtocols.has(partedURL[0]);
+    let hostPartUrl = ["http", ...partedURL.slice(1)].join(":");
+    if (!this._hasHostpart) {
+      const pathname = hostPartUrl.replace(/http:\/\/[/]*/, "").replace(/[#?].*$/, "");
+      hostPartUrl = hostPartUrl.replace(/http:\/\//, `http://localhost/${pathname}`);
+    }
+    try {
+      this._sysURL = new URL(hostPartUrl);
+    } catch (ie) {
+      const e = ie as Error;
+      e.message = `${e.message} for URL: ${urlStr}`;
+      throw e;
+    }
+    this._protocol = `${partedURL[0]}:`; // this._sysURL.protocol.replace(new RegExp("^cement-"), "");
+    if (this._hasHostpart) {
+      this._pathname = this._sysURL.pathname;
+    } else {
+      this._pathname = urlStr.replace(new RegExp(`^${this._protocol}//`), "").replace(/[#?].*$/, "");
+    }
+    // this.hash = this._sysURL.hash;
+  }
+
+  set origin(h: string) {
+    throw new Error("origin is readonly");
+  }
+
+  override get href(): string {
+    return this.toString();
+  }
+
+  set href(h: string) {
+    throw new Error("href is readonly");
+  }
+
+  override get password(): string {
+    return this._sysURL.password;
+  }
+
+  set password(h: string) {
+    throw new Error("password is readonly");
+  }
+
+  override get username(): string {
+    return this._sysURL.username;
+  }
+
+  set username(h: string) {
+    throw new Error("username is readonly");
+  }
+
+  toJSON(): string {
+    return this.toString();
+  }
+
+  [customInspectSymbol](): string {
+    // make node inspect to show the URL and not crash if URI is not http/https/file
+    return this.toString();
+  }
+
+  clone(): ReadonlyURL {
+    return this;
+  }
+
+  // Hash getter and setter
+  override get hash(): string {
+    return this._sysURL.hash;
+  }
+
+  set hash(h: string) {
+    throw new Error("hash is readonly");
+  }
+
+  // Host getter and setter
+  get host(): string {
+    if (!this._hasHostpart) {
+      throw new Error(
+        `you can use hostname only if protocol is ${this.toString()} ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`,
+      );
+    }
+    return this._sysURL.host;
+  }
+
+  set host(h: string) {
+    throw new Error("host is readonly");
+  }
+
+  // Hostname getter and setter
+  get hostname(): string {
+    if (!this._hasHostpart) {
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
+    }
+    return this._sysURL.hostname;
+  }
+
+  set hostname(h: string) {
+    throw new Error("hostname is readonly");
+  }
+
+  // Pathname getter and setter
+  override get pathname(): string {
+    return this._pathname;
+  }
+
+  set pathname(h: string) {
+    throw new Error("pathname is readonly");
+  }
+
+  // Port getter and setter
+  override get port(): string {
+    if (!this._hasHostpart) {
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
+    }
+    return this._sysURL.port;
+  }
+
+  set port(h: string) {
+    throw new Error("port is readonly");
+  }
+
+  // Protocol getter and setter
+  override get protocol(): string {
+    return this._protocol;
+  }
+
+  set protocol(h: string) {
+    throw new Error("protocol is readonly");
+  }
+
+  // Search getter and setter
+  get search(): string {
+    let search = "";
+    if (this._sysURL.searchParams.size) {
+      for (const [key, value] of Array.from(URLSearchParamsEntries(this._sysURL.searchParams)).sort((a, b) =>
+        a[0].localeCompare(b[0]),
+      )) {
+        search += `${!search.length ? "?" : "&"}${key}=${encodeURIComponent(value)}`;
+      }
+    }
+    return search;
+  }
+
+  set search(h: string) {
+    throw new Error("search is readonly");
+  }
+
+  // SearchParams getter and setter
+  override get searchParams(): URLSearchParams {
+    return this._sysURL.searchParams;
+  }
+
+  set searchParams(h: URLSearchParams) {
+    throw new Error("searchParams is readonly");
+  }
+
+  override toString(): string {
+    const search = this.search;
+    let hostpart = "";
+    if (this._hasHostpart) {
+      hostpart = this._sysURL.hostname;
+      if (this._sysURL.port) {
+        hostpart += `:${this._sysURL.port}`;
+      }
+      if (!this._pathname.startsWith("/")) {
+        hostpart += "/";
+      }
+    }
+    if (this.username || this.password) {
+      hostpart = `${this.username}:${this.password}@${hostpart}`;
+    }
+    return `${this._protocol}//${hostpart}${this._pathname}${search}${this.hash}`;
+  }
+}
+
+export class WritableURL extends ReadonlyURL {
+  // override readonly hash: string;
+
+  static readonly fromThrow = (urlStr: string): WritableURL => {
+    return new WritableURL(urlStr);
+  };
+
+  static from(urlStr: string): Result<WritableURL> {
+    if (urlRegex.test(urlStr)) {
+      return exception2Result(() => new WritableURL(urlStr));
+    }
+    return Result.Err(`Invalid URL: ${urlStr}`);
+  }
+
+  private constructor(urlStr: string) {
+    super(urlStr);
+  }
+
+  override toJSON(): string {
+    return this.toString();
+  }
+
+  [customInspectSymbol](): string {
+    // make node inspect to show the URL and not crash if URI is not http/https/file
+    return this.toString();
+  }
+
+  clone(): WritableURL {
+    return new WritableURL(this.toString());
+  }
+
+  set origin(_h: string) {
+    throw new Error("don't use origin");
+  }
+
+  get href(): string {
+    return super.href;
+  }
+
+  set href(h: string) {
+    throw new Error("don't use href");
+  }
+
+  override get password(): string {
+    return super.password;
+  }
+
+  set password(h: string) {
+    this._sysURL.password = h;
+  }
+
+  override get username(): string {
+    return super.username;
+  }
+
+  set username(h: string) {
+    this._sysURL.username = h;
+  }
+
+  // Hash getter and setter
+  override get hash(): string {
+    return super.hash;
+  }
+
+  override set hash(h: string) {
+    this._sysURL.hash = h;
+  }
+
+  // Host getter and setter
+  override get host(): string {
+    return super.host;
+  }
+
+  override set host(h: string) {
+    this._sysURL.host = h;
+  }
+
+  // Hostname getter and setter
+  override get hostname(): string {
+    return super.hostname;
+  }
+
+  override set hostname(h: string) {
+    if (!this._hasHostpart) {
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
+    }
+    this._sysURL.hostname = h;
+  }
+
+  // Pathname getter and setter
+  override get pathname(): string {
+    return super.pathname;
+  }
+
+  override set pathname(p: string) {
+    this._pathname = p;
+  }
+
+  // Port getter and setter
+  override get port(): string {
+    return super.port;
+  }
+
+  override set port(p: string) {
+    if (!this._hasHostpart) {
+      throw new Error(`you can use port only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
+    }
+    this._sysURL.port = p;
+  }
+
+  // Protocol getter and setter
+  override get protocol(): string {
+    return super.protocol;
+  }
+
+  override set protocol(p: string) {
+    if (!p.endsWith(":")) {
+      p = `${p}:`;
+    }
+    this._protocol = p;
+  }
+
+  // Search getter and setter
+  override get search(): string {
+    return super.search;
+  }
+
+  override set search(h: string) {
+    this._sysURL.search = h;
+  }
+
+  // SearchParams getter and setter
+  override get searchParams(): URLSearchParams {
+    return super.searchParams;
+  }
+
+  override set searchParams(h: URLSearchParams) {
+    const toDel = new Set<string>();
+    for (const [key] of URLSearchParamsEntries(this._sysURL.searchParams)) {
+      toDel.add(key);
+    }
+    for (const [key, value] of URLSearchParamsEntries(h)) {
+      this._sysURL.searchParams.set(key, value);
+      toDel.delete(key);
+    }
+    for (const key of toDel) {
+      this._sysURL.searchParams.delete(key);
+    }
+  }
+}