acrylblends 0.7.7 → 0.8.0

package/templates/todo/upstream.json

@@ -5,8 +5,8 @@
       "examples/acryl-todo/src/index.ts": "src/todo.ts",
       "examples/acryl-todo/src/page.ts": "src/page.ts"
     },
-    "commit": "f8e385e4389fe2fdc6fd2a4366a7f2a7389faacb"
+    "commit": "20bdc263d6f0f8febbd967007bda4cf4a802efd2"
   },
   "rewrittenSpecifiers": 4,
-  "digest": "sha256:9093704776563001f7f472f94cc5c2fdd79206342c1cb59c11fce62aa74df3ed"
+  "digest": "sha256:48d10af77d542ea0bf18cd3476ec9dc1f1225c8e7644c21492236de8c1d4a73c"
 }

package/lib/database-D_UN6We8.d.ts

@@ -1,44 +0,0 @@
-//#region ../../plugins/acryl-db/lib/types/facade/database.d.ts
-/** Values supported by the portable SQL drivers. */
-type SqlValue = null | number | bigint | string | Uint8Array;
-/**
- * Asynchronous SQL operations shared by a database and its transaction handles.
- *
- * `exec` runs SQL text without bindings and may contain several statements. `run`, `get`, and `all`
- * execute one statement with positional bindings. Adapters may cache prepared statements by SQL text,
- * so callers pass values as bindings instead of interpolating them. `run` resolves the number of rows
- * the statement changed.
- */
-interface DbExecutor {
-  exec(sql: string): Promise<void>;
-  run(sql: string, ...params: SqlValue[]): Promise<{
-    readonly changes: number;
-  }>;
-  get<T extends object>(sql: string, ...params: SqlValue[]): Promise<T | undefined>;
-  all<T extends object>(sql: string, ...params: SqlValue[]): Promise<T[]>;
-}
-/**
- * Minimal portable SQL database facade.
- *
- * All operations are asynchronous so adapters may execute outside the caller's runtime.
- *
- * `transaction` passes the callback a transaction handle. All work in the transaction
- * must use that handle; the handle is invalid after the callback settles. Adapters must
- * queue unrelated operations and other transactions until the transaction finishes. The
- * returned promise settles after commit or rollback. Calling the database itself (including
- * `transaction`) from inside a callback therefore waits for that transaction and
- * never settles.
- *
- * When the callback rejects, the adapter must roll the transaction back before rejecting
- * with that same error. If rollback fails, it must reject with a different error (for
- * example an `AggregateError`) so callers cannot mistake the callback error for a
- * guaranteed rollback.
- *
- * Closing is the adapter's: the plugin that opened a database closes it, so the facade an
- * app receives has no `close`.
- */
-interface Db extends DbExecutor {
-  transaction<T>(callback: (transaction: DbExecutor) => Promise<T>): Promise<T>;
-}
-//#endregion
-export { DbExecutor as n, SqlValue as r, Db as t };

package/lib/kv-DWDm0Lja.d.ts

@@ -1,39 +0,0 @@
-//#region ../../plugins/acryl-kv/lib/types/kv.d.ts
-/** `T`, except a promise: the callback of `update` is synchronous, and an async one is a type error. */
-type NotPromise<T> = T extends PromiseLike<unknown> ? never : T;
-/** Anything JSON can hold. */
-type JsonValue = null | boolean | number | string | JsonValue[] | {
-  [key: string]: JsonValue;
-};
-/**
- * Named JSON documents. Every call returns a promise, so a file, SQLite and Postgres answer alike.
- *
- * Keys are non-empty strings. Values are JSON: `undefined`, functions, symbols, bigints and non-finite numbers are refused with a
- * `TypeError` before anything is written, and a value read back is a copy.
- *
- * There is no `close`: the code that opened a store closes it (see {@link KvOpened}), so a plugin cannot close the store another uses.
- */
-interface Kv {
-  /** The value stored under the key, or `undefined`. */
-  get<T = JsonValue>(key: string): Promise<T | undefined>;
-  /** Store a value under the key, replacing any. Resolves once it is durable. */
-  set<T = JsonValue>(key: string, value: T): Promise<void>;
-  /**
-   * Replace the value under the key by `change(current)`, atomically: `current` is `undefined` when the key is missing, `change` is
-   * synchronous (an `async` function is a type error, and a returned promise is rejected at run time: read what you need first, then update), and no other write to the key happens between reading it and writing the result. Resolves the new value. A `change` that
-   * throws, or returns something that is not JSON, leaves the value as it was and rejects with its error.
-   */
-  update<T = JsonValue>(key: string, change: (current: T | undefined) => NotPromise<T>): Promise<T>;
-  /** Remove the key. A missing key is not an error. */
-  delete(key: string): Promise<void>;
-  /** The keys that start with the prefix (all of them without one), sorted by code point (the order of their UTF-8 bytes, not of UTF-16 units). */
-  list(prefix?: string): Promise<string[]>;
-}
-/** An open store and the one function that closes it. */
-interface KvOpened {
-  readonly kv: Kv;
-  /** Waits for the writes in flight, then releases the storage. Calling it again does nothing; calls on `kv` after it reject. */
-  close(): Promise<void>;
-}
-//#endregion
-export { KvOpened as n, Kv as t };