k99 0.6.0-alpha.1 → 0.6.0-alpha.3

package/browser.cjs

@@ -0,0 +1,457 @@
+/*!
+ * k99 v0.6.0-alpha.3
+ * (c) 2019-2023 猛火Fierflame
+ * @license MIT
+ */
+'use strict';
+
+function createSettingsApi$1(cache, root) {
+  return {
+    async read(path) {
+      path = `${root}${path}`;
+      const response = await cache.match(path);
+      if (!response) {
+        return undefined;
+      }
+      return response.json();
+    },
+    async write(path, cfg) {
+      path = `${root}${path}`;
+      if (cfg === undefined) {
+        return cache.delete(path);
+      }
+      await cache.put(path, new Response(JSON.stringify(cfg)));
+      return true;
+    }
+  };
+}
+function createAssetsApi$1(cache, root) {
+  return {
+    async read(path) {
+      path = `${root}${path}`;
+      const response = await cache.match(path);
+      if (!response) {
+        return null;
+      }
+      return new Uint8Array(await response.arrayBuffer());
+    },
+    async write(path, data) {
+      path = `${root}${path}`;
+      await cache.put(path, new Response(data));
+      return true;
+    },
+    async delete(path) {
+      path = `${root}${path}`;
+      return cache.delete(path);
+    },
+    stat() {
+      return null;
+    }
+  };
+}
+function createLogApi$1(cache, root) {
+  return {
+    async read(path) {
+      path = `${root}${path}`;
+      const response = await cache.match(path);
+      return response ? response.text() : '';
+    },
+    async write(path, log) {
+      path = `${root}${path}`;
+      const response = await cache.match(path);
+      const text = `${(await response?.text()) || ''}${log}\n`;
+      await cache.put(path, new Response(text));
+      return true;
+    },
+    async clear(path) {
+      path = `${root}${path}`;
+      await cache.delete(path);
+    }
+  };
+}
+async function createCacheApis(name = 'k99', {
+  assets = '/k99/assets',
+  log = '/k99/log',
+  settings = '/k99/settings'
+} = {}) {
+  const cache = await caches.open(name);
+  if (assets[assets.length - 1] !== '/') {
+    assets = `${assets}/`;
+  }
+  if (assets[0] !== '/') {
+    assets = `/${assets}`;
+  }
+  if (log[log.length - 1] !== '/') {
+    log = `${log}/`;
+  }
+  if (log[0] !== '/') {
+    log = `/${log}`;
+  }
+  if (settings[log.length - 1] !== '/') {
+    settings = `${settings}/`;
+  }
+  if (settings[0] !== '/') {
+    settings = `/${settings}`;
+  }
+  return {
+    logApi: createLogApi$1(cache, log),
+    assetsApi: createAssetsApi$1(cache, assets),
+    settingsApi: createSettingsApi$1(cache, settings)
+  };
+}
+
+function createAssetsApi(db, store) {
+  return {
+    async read(path) {
+      return new Promise(r => {
+        const request = db.transaction(store).objectStore(store).get(path);
+        request.addEventListener('error', () => r(null));
+        request.addEventListener('success', () => r(request.result || null));
+      });
+    },
+    async write(path, data) {
+      return new Promise(r => {
+        const request = db.transaction(store, 'readwrite').objectStore(store).add(data, path);
+        request.addEventListener('error', () => r(false));
+        request.addEventListener('success', () => r(true));
+      });
+    },
+    async delete(path) {
+      return new Promise(r => {
+        const request = db.transaction(store, 'readwrite').objectStore(store).delete(path);
+        request.addEventListener('error', () => r(false));
+        request.addEventListener('success', () => r(true));
+      });
+    },
+    stat() {
+      return null;
+    }
+  };
+}
+function createSettingsApi(db, store) {
+  return {
+    async read(path) {
+      return new Promise(r => {
+        const request = db.transaction(store).objectStore(store).get(path);
+        request.addEventListener('error', () => r(null));
+        request.addEventListener('success', () => r(request.result || null));
+      });
+    },
+    async write(path, cfg) {
+      if (cfg === null || cfg === undefined) {
+        return new Promise(r => {
+          const request = db.transaction(store, 'readwrite').objectStore(store).delete(path);
+          request.addEventListener('error', () => r(false));
+          request.addEventListener('success', () => r(true));
+        });
+      }
+      return new Promise(r => {
+        const request = db.transaction(store, 'readwrite').objectStore(store).add(cfg, path);
+        request.addEventListener('error', () => r(false));
+        request.addEventListener('success', () => r(true));
+      });
+    }
+  };
+}
+function createLogApi(db, store) {
+  return {
+    async read(path) {
+      return new Promise(r => {
+        const request = db.transaction(store).objectStore(store).get(path);
+        request.addEventListener('error', () => r(''));
+        request.addEventListener('success', () => r(request.result || null));
+      });
+    },
+    async write(path, log) {
+      return new Promise(r => {
+        const transaction = db.transaction(store, 'readwrite');
+        const request = transaction.objectStore(store).get(path);
+        request.addEventListener('error', () => r(false));
+        request.addEventListener('success', () => {
+          const request2 = transaction.objectStore(store).add(`${request.result || ''}${log}\n`, path);
+          request2.addEventListener('error', () => r(false));
+          request2.addEventListener('success', () => r(true));
+        });
+      });
+    },
+    async clear(path) {
+      return new Promise(r => {
+        const request = db.transaction(store, 'readwrite').objectStore(store).delete(path);
+        request.addEventListener('error', () => r());
+        request.addEventListener('success', () => r());
+      });
+    }
+  };
+}
+function createIndexedApis(database = 'k99', {
+  assets = 'assets',
+  log = 'log',
+  settings = 'settings'
+} = {}, version = 1) {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(database, version);
+    req.addEventListener('upgradeneeded', e => {
+      const db = e.target.result;
+      db.createObjectStore(assets);
+      db.createObjectStore(log);
+      db.createObjectStore(settings);
+    });
+    req.addEventListener('error', () => reject(req.error));
+    req.addEventListener('success', () => resolve(req.result));
+  }).then(db => ({
+    logApi: createLogApi(db, log),
+    assetsApi: createAssetsApi(db, assets),
+    settingsApi: createSettingsApi(db, settings)
+  }));
+}
+
+function createStreamRead(readableStream) {
+  let reader;
+  let current = 0;
+  let cb = null;
+  let end = false;
+  const dataList = [];
+  let dataSize = 0;
+  const list = [];
+  function get() {
+    if (!current || dataSize <= current) {
+      const chunk = new Uint8Array(dataSize);
+      let index = 0;
+      for (const item of dataList) {
+        for (let i = 0; i < item.byteLength; i++, index++) {
+          chunk[index] = item[i];
+        }
+      }
+      dataSize = 0;
+      dataList.length = 0;
+      return chunk;
+    }
+    let item = dataList.shift();
+    if (!item) {
+      return null;
+    }
+    const chunk = new Uint8Array(current);
+    let index = 0;
+    let i = 0;
+    let len = item.length;
+    while (index < current) {
+      if (i >= length) {
+        item = dataList.shift();
+        if (!item) {
+          break;
+        }
+        i = 0;
+        len = item.length;
+      }
+      chunk[index] = item[i];
+      i++;
+      index++;
+    }
+    if (item && i < len) {
+      dataList.unshift(new Uint8Array(item.buffer.slice(i)));
+    }
+    dataSize -= current;
+    return chunk;
+  }
+  function add(data) {
+    dataSize += data.length || 0;
+    dataList.push(data);
+    return dataSize;
+  }
+  function runCb() {
+    if (!cb) {
+      return;
+    }
+    const v = dataSize ? get() : null;
+    cb(v);
+    [current, cb] = list.shift() || [0, null];
+  }
+  async function run() {
+    for (;;) {
+      if (!cb) {
+        break;
+      }
+      if (end) {
+        runCb();
+        continue;
+      }
+      if (dataSize && (!current || dataSize >= current)) {
+        runCb();
+        continue;
+      }
+      const {
+        value,
+        done
+      } = await reader.read();
+      if (done) {
+        end = true;
+        continue;
+      }
+      add(value);
+      if (dataSize && (!current || dataSize >= current)) {
+        runCb();
+        continue;
+      }
+    }
+  }
+  function read(size = 0) {
+    return new Promise(resolve => {
+      if (!reader) {
+        reader = readableStream.getReader();
+      }
+      size = Math.max(size, 0);
+      if (cb) {
+        list.push([size, resolve]);
+        return;
+      }
+      current = size;
+      cb = resolve;
+      run();
+    });
+  }
+  return read;
+}
+
+function createBufferRead(request) {
+  let arrayBuffer;
+  function read(size = 0) {
+    if (!arrayBuffer) {
+      arrayBuffer = request.arrayBuffer().then(t => [new Uint8Array(0), new Uint8Array(t), 0]);
+    }
+    arrayBuffer = arrayBuffer.then(v => {
+      if (!v) {
+        return null;
+      }
+      let [, buff, index] = v;
+      if (index >= buff.byteLength) {
+        return null;
+      }
+      if (!size || size + index >= buff.byteLength) {
+        return [buff.slice(index), buff, buff.byteLength];
+      }
+      let end = index + size;
+      return [buff.slice(index, end), buff, end];
+    });
+    return arrayBuffer.then(v => {
+      if (!v) {
+        return null;
+      }
+      const [value] = v;
+      return value;
+    });
+  }
+  return read;
+}
+
+function getNameValue(s) {
+  const index = s.indexOf('=');
+  if (index < 0) {
+    return [decodeURIComponent(s), ''];
+  }
+  return [decodeURIComponent(s.substring(0, index)), decodeURIComponent(s.substring(index + 1))];
+}
+function parseQuery(s) {
+  const query = {};
+  for (const k of s.split('&').filter(Boolean)) {
+    const [index, value] = getNameValue(k);
+    if (index in query) {
+      query[index] = [query[index], value].flat();
+    } else {
+      query[index] = value;
+    }
+  }
+  return query;
+}
+function getHeaders(h) {
+  const headers = {};
+  for (const [k, v] of h.entries()) {
+    headers[k.toLowerCase()] = v;
+  }
+  return headers;
+}
+function createRequest(request, searchParser = parseQuery) {
+  const url = new URL(request.url);
+  const {
+    body,
+    signal
+  } = request;
+  const aborted = new Promise((_, reject) => {
+    if (signal.aborted) {
+      return reject(signal.reason);
+    }
+    signal.addEventListener('abort', () => reject(signal.reason), {
+      once: true
+    });
+  });
+  return {
+    method: (request.method || 'GET').toUpperCase(),
+    url: `${url.pathname}${url.search}` || '/',
+    headers: getHeaders(request.headers),
+    pathname: url.pathname || '/',
+    search: url.search || '',
+    query: searchParser(url.search.substring(1)),
+    aborted,
+    read: body ? createStreamRead(body) : createBufferRead(request)
+  };
+}
+
+function createHeaders(target) {
+  const headers = new Headers();
+  for (const [k, v] of Object.entries(target.headers)) {
+    for (const it of [v].flat()) {
+      headers.append(k.toLowerCase(), String(it));
+    }
+  }
+  return headers;
+}
+function createResponse(target) {
+  return new Response(new ReadableStream({
+    async pull(controller) {
+      const {
+        value,
+        done
+      } = await target.next();
+      if (done) {
+        controller.close();
+      } else {
+        controller.enqueue(value);
+      }
+    },
+    async cancel(reason) {
+      return target.throw(reason).then(() => {}, () => {});
+    }
+  }), {
+    status: target.status,
+    headers: createHeaders(target)
+  });
+}
+
+function createFetch(run, notFound, searchParser) {
+  return async function fetch(input, init) {
+    const request = new Request(input, init);
+    const {
+      signal
+    } = request;
+    if (signal.aborted) {
+      return Promise.reject(new DOMException('The user aborted a request.'));
+    }
+    const r = await run(createRequest(request, searchParser));
+    if (r) {
+      return createResponse(r);
+    }
+    if (typeof notFound === 'function') {
+      return notFound(request);
+    }
+    return new Response(null, {
+      status: 404
+    });
+  };
+}
+
+exports.createBufferRead = createBufferRead;
+exports.createCacheApis = createCacheApis;
+exports.createFetch = createFetch;
+exports.createIndexedApis = createIndexedApis;
+exports.createRequest = createRequest;
+exports.createResponse = createResponse;
+exports.createStreamRead = createStreamRead;

package/{browser/index.d.ts → browser.d.ts}

@@ -1,5 +1,5 @@
 /*!
- * k99 v0.6.0-alpha.1
+ * k99 v0.6.0-alpha.3
  * (c) 2019-2023 猛火Fierflame
  * @license MIT
  */

package/{browser/index.js → browser.js}

@@ -1,5 +1,5 @@
 /*!
- * k99 v0.6.0-alpha.1
+ * k99 v0.6.0-alpha.3
  * (c) 2019-2023 猛火Fierflame
  * @license MIT
  */

package/{browser/index.min.js → browser.min.js}

@@ -1,5 +1,5 @@
 /*!
- * k99 v0.6.0-alpha.1
+ * k99 v0.6.0-alpha.3
  * (c) 2019-2023 猛火Fierflame
  * @license MIT
  */

package/{browser/index.min.mjs → browser.min.mjs}

@@ -1,5 +1,5 @@
 /*!
- * k99 v0.6.0-alpha.1
+ * k99 v0.6.0-alpha.3
  * (c) 2019-2023 猛火Fierflame
  * @license MIT
  */

package/{browser/index.mjs → browser.mjs}

@@ -1,5 +1,5 @@
 /*!
- * k99 v0.6.0-alpha.1
+ * k99 v0.6.0-alpha.3
  * (c) 2019-2023 猛火Fierflame
  * @license MIT
  */

package/cli/{index.mjs → index.cjs}

@@ -1,11 +1,33 @@
 /*!
- * k99 v0.6.0-alpha.1
+ * k99 v0.6.0-alpha.3
  * (c) 2019-2023 猛火Fierflame
  * @license MIT
  */
-import * as http from 'node:http';
-import { start as start$1, createHttpCallback } from 'k99/node';
-import * as fsPromise from 'node:fs/promises';
+'use strict';
+
+var http = require('node:http');
+var node = require('k99/node');
+var fsPromise = require('node:fs/promises');
+
+function _interopNamespaceDefault(e) {
+	var n = Object.create(null);
+	if (e) {
+		Object.keys(e).forEach(function (k) {
+			if (k !== 'default') {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	}
+	n.default = e;
+	return Object.freeze(n);
+}
+
+var http__namespace = /*#__PURE__*/_interopNamespaceDefault(http);
+var fsPromise__namespace = /*#__PURE__*/_interopNamespaceDefault(fsPromise);
 
 async function exec$1({
   path,
@@ -16,9 +38,9 @@ async function exec$1({
   if (path) {
     process.chdir(path);
   }
-  const router = await start$1();
-  console.log('K99', '@', router.cwd);
-  const server = http.createServer(createHttpCallback(router.run));
+  const r = await node.start();
+  console.log('K99', '@');
+  const server = http__namespace.createServer(node.createHttpCallback(r));
   // (global as any).router = router;
   if (listen && typeof listen === 'string') {
     server.listen(listen);
@@ -51,21 +73,21 @@ async function exec({
   path
 }, ...args) {
   if (path) {
-    await fsPromise.mkdir(path, {
+    await fsPromise__namespace.mkdir(path, {
       recursive: true
     }).catch(() => {});
     process.chdir(path);
   }
   console.log('K99', '@', process.cwd());
   for (const n of configFileNames) {
-    if (await fsPromise.stat(n).then(() => true, () => false)) {
+    if (await fsPromise__namespace.stat(n).then(() => true, () => false)) {
       console.log(`The config (${n}) is Existing.`);
       return;
     }
   }
-  await fsPromise.writeFile('.k99.config.json', JSON.stringify({}, null, '\t'));
-  await fsPromise.writeFile('k99.config.js', entryFile);
-  const cfg = JSON.stringify(await fsPromise.readFile('package.json', 'utf-8').catch(() => {})) || {
+  await fsPromise__namespace.writeFile('.k99.config.json', JSON.stringify({}, null, '\t'));
+  await fsPromise__namespace.writeFile('k99.config.js', entryFile);
+  const cfg = JSON.stringify(await fsPromise__namespace.readFile('package.json', 'utf-8').catch(() => {})) || {
     private: true
   };
   if (!cfg.main) {
@@ -84,9 +106,9 @@ async function exec({
     cfg.dependencies = {};
   }
   if (!cfg.dependencies.k99) {
-    cfg.dependencies.k99 = '^0.6.0-alpha.1';
+    cfg.dependencies.k99 = '^0.6.0-alpha.3';
   }
-  await fsPromise.writeFile('package.json', JSON.stringify(cfg, null, 2));
+  await fsPromise__namespace.writeFile('package.json', JSON.stringify(cfg, null, 2));
 }
 const opts = ['path'];
 const argv = '';
@@ -173,4 +195,6 @@ const opt = {
   port
 };
 
-export { index as command, opt as options, start };
+exports.command = index;
+exports.options = opt;
+exports.start = start;

package/cli/index.d.ts

@@ -1,5 +1,5 @@
 /*!
- * k99 v0.6.0-alpha.1
+ * k99 v0.6.0-alpha.3
  * (c) 2019-2023 猛火Fierflame
  * @license MIT
  */

package/cli.cjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/*!
+ * k99 v0.6.0-alpha.3
+ * (c) 2019-2023 猛火Fierflame
+ * @license MIT
+ */
+'use strict';
+
+var entryCli = require('entry-cli');
+var cli = require('k99/cli');
+
+entryCli.cli(cli.command, cli.options, {
+  execCmd: 'k99'
+})(process.argv.slice(2));