k99 0.6.0-alpha.1 → 0.6.0-alpha.2

package/app.cjs

@@ -0,0 +1,43 @@
+/*!
+ * k99 v0.6.0-alpha.2
+ * (c) 2019-2023 猛火Fierflame
+ * @license MIT
+ */
+'use strict';
+
+var run = require('k99');
+var Plugin = require('k99/plugin');
+var Router = require('k99/router');
+
+class App {
+  /** 设置接口 */
+
+  /** 资产接口 */
+
+  /** 日志接口 */
+
+  routers = [];
+  constructor({
+    router,
+    setting,
+    asset,
+    log
+  } = {}, plugins = {}) {
+    this.setting = setting;
+    this.asset = Plugin.bindAsset(asset, plugins);
+    this.log = log;
+    this.plugins = plugins;
+    const {
+      routers
+    } = this;
+    for (const plugin of Object.values(plugins)) {
+      routers.push(plugin.router);
+    }
+    if (router instanceof Router) {
+      routers.push(router);
+    }
+    this.run = run.make(Router.make(routers), this);
+  }
+}
+
+module.exports = App;

package/app.d.ts

@@ -0,0 +1,31 @@
+/*!
+ * k99 v0.6.0-alpha.2
+ * (c) 2019-2023 猛火Fierflame
+ * @license MIT
+ */
+import { Setting, Asset, Log, K99Request, K99Response } from 'k99';
+import Plugin from 'k99/plugin';
+import Router from 'k99/router';
+
+declare class App {
+    /** 设置接口 */
+    readonly setting?: Setting.Api;
+    /** 资产接口 */
+    readonly asset?: Asset.Api;
+    /** 日志接口 */
+    readonly log?: Log.Api;
+    readonly plugins: Record<string, Plugin>;
+    readonly routers: Router[];
+    readonly run: (request: K99Request) => Promise<null | K99Response>;
+    constructor({ router, setting, asset, log }?: App.Options, plugins?: Record<string, Plugin>);
+}
+declare namespace App {
+    interface Options {
+        router?: Router;
+        asset?: Asset.Api;
+        setting?: Setting.Api;
+        log?: Log.Api;
+    }
+}
+
+export { App as default };

package/app.js

@@ -0,0 +1,45 @@
+/*!
+ * k99 v0.6.0-alpha.2
+ * (c) 2019-2023 猛火Fierflame
+ * @license MIT
+ */
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('k99'), require('k99/plugin'), require('k99/router')) :
+	typeof define === 'function' && define.amd ? define(['k99', 'k99/plugin', 'k99/router'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.k99App = factory(global.k99, global.k99Plugin, global.k99Router));
+})(this, (function (run, Plugin, Router) { 'use strict';
+
+	class App {
+	  /** 设置接口 */
+
+	  /** 资产接口 */
+
+	  /** 日志接口 */
+
+	  routers = [];
+	  constructor({
+	    router,
+	    setting,
+	    asset,
+	    log
+	  } = {}, plugins = {}) {
+	    this.setting = setting;
+	    this.asset = Plugin.bindAsset(asset, plugins);
+	    this.log = log;
+	    this.plugins = plugins;
+	    const {
+	      routers
+	    } = this;
+	    for (const plugin of Object.values(plugins)) {
+	      routers.push(plugin.router);
+	    }
+	    if (router instanceof Router) {
+	      routers.push(router);
+	    }
+	    this.run = run.make(Router.make(routers), this);
+	  }
+	}
+
+	return App;
+
+}));

package/app.min.js

@@ -0,0 +1,6 @@
+/*!
+ * k99 v0.6.0-alpha.2
+ * (c) 2019-2023 猛火Fierflame
+ * @license MIT
+ */
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t(require("k99"),require("k99/plugin"),require("k99/router")):"function"==typeof define&&define.amd?define(["k99","k99/plugin","k99/router"],t):(e="undefined"!=typeof globalThis?globalThis:e||self).k99App=t(e.k99,e.k99Plugin,e.k99Router)}(this,(function(e,t,s){"use strict";return class{routers=[];constructor({router:i,setting:o,asset:r,log:u}={},n={}){this.setting=o,this.asset=t.bindAsset(r,n),this.log=u,this.plugins=n;const{routers:f}=this;for(const e of Object.values(n))f.push(e.router);i instanceof s&&f.push(i),this.run=e.make(s.make(f),this)}}}));

package/app.min.mjs

@@ -0,0 +1,6 @@
+/*!
+ * k99 v0.6.0-alpha.2
+ * (c) 2019-2023 猛火Fierflame
+ * @license MIT
+ */
+import t from"k99";import s from"k99/plugin";import o from"k99/router";class r{routers=[];constructor({router:r,setting:e,asset:i,log:u}={},n={}){this.setting=e,this.asset=s.bindAsset(i,n),this.log=u,this.plugins=n;const{routers:a}=this;for(const t of Object.values(n))a.push(t.router);r instanceof o&&a.push(r),this.run=t.make(o.make(a),this)}}export{r as default};

package/app.mjs

@@ -0,0 +1,41 @@
+/*!
+ * k99 v0.6.0-alpha.2
+ * (c) 2019-2023 猛火Fierflame
+ * @license MIT
+ */
+import run from 'k99';
+import Plugin from 'k99/plugin';
+import Router from 'k99/router';
+
+class App {
+  /** 设置接口 */
+
+  /** 资产接口 */
+
+  /** 日志接口 */
+
+  routers = [];
+  constructor({
+    router,
+    setting,
+    asset,
+    log
+  } = {}, plugins = {}) {
+    this.setting = setting;
+    this.asset = Plugin.bindAsset(asset, plugins);
+    this.log = log;
+    this.plugins = plugins;
+    const {
+      routers
+    } = this;
+    for (const plugin of Object.values(plugins)) {
+      routers.push(plugin.router);
+    }
+    if (router instanceof Router) {
+      routers.push(router);
+    }
+    this.run = run.make(Router.make(routers), this);
+  }
+}
+
+export { App as default };

package/browser.cjs

@@ -0,0 +1,457 @@
+/*!
+ * k99 v0.6.0-alpha.2
+ * (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.2
  * (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.2
  * (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.2
  * (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.2
  * (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.2
  * (c) 2019-2023 猛火Fierflame
  * @license MIT
  */

package/cli/index.d.ts

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