@gamely/gly-engine-lite 0.0.18 → 0.0.20

package/dist/main.lua

@@ -1,43 +1,48 @@
 local math = ((function() local x, y = pcall(require, 'math'); return x and y end)()) or _G.math
-local src_version_561fa16ca630 = nil
-local src_lib_common_module_561fa16cab70 = nil
-local src_lib_engine_api_encoder_561fa16cb2c0 = nil
-local src_lib_engine_api_app_561fa16cff00 = nil
-local src_lib_engine_api_hash_561fa16d0530 = nil
-local src_lib_engine_api_http_561fa16d0b50 = nil
-local src_lib_engine_api_i18n_561fa16d10f0 = nil
-local src_lib_engine_api_key_561fa16d1700 = nil
-local src_lib_engine_api_math_561fa16c5900 = nil
-local src_lib_engine_api_array_561fa16c1450 = nil
-local src_lib_engine_api_media_561fa16cce10 = nil
-local src_lib_engine_draw_fps_561fa16c6900 = nil
-local src_lib_engine_draw_text_561fa16c8d50 = nil
-local src_lib_engine_draw_poly_561fa16ca270 = nil
-local src_lib_engine_raw_memory_561fa16caab0 = nil
-local src_lib_object_root_561fa16cb030 = nil
-local src_lib_object_color_561fa16d0260 = nil
-local src_lib_object_std_561fa16c9dc0 = nil
-local src_lib_util_pipeline_561fa16c26b0 = nil
-local src_lib_util_decorator_561fa16bfce0 = nil
-local function main_561fa16ca3f0()
-local version = src_version_561fa16ca630()
-local zeebo_module = src_lib_common_module_561fa16cab70()
-local engine_encoder = src_lib_engine_api_encoder_561fa16cb2c0()
-local engine_game = src_lib_engine_api_app_561fa16cff00()
-local engine_hash = src_lib_engine_api_hash_561fa16d0530()
-local engine_http = src_lib_engine_api_http_561fa16d0b50()
-local engine_i18n = src_lib_engine_api_i18n_561fa16d10f0()
-local engine_key = src_lib_engine_api_key_561fa16d1700()
-local engine_math = src_lib_engine_api_math_561fa16c5900()
-local engine_array = src_lib_engine_api_array_561fa16c1450()
-local engine_media = src_lib_engine_api_media_561fa16cce10()
-local engine_draw_fps = src_lib_engine_draw_fps_561fa16c6900()
-local engine_draw_text = src_lib_engine_draw_text_561fa16c8d50()
-local engine_draw_poly = src_lib_engine_draw_poly_561fa16ca270()
-local engine_raw_memory = src_lib_engine_raw_memory_561fa16caab0()
-local application_default = src_lib_object_root_561fa16cb030()
-local color = src_lib_object_color_561fa16d0260()
-local std = src_lib_object_std_561fa16c9dc0()
+local src_version_55789ed81210 = nil
+local src_lib_common_module_55789ed58c40 = nil
+local src_lib_engine_api_encoder_55789ed92660 = nil
+local src_lib_engine_api_app_55789eda8c90 = nil
+local src_lib_engine_api_hash_55789ed5fba0 = nil
+local src_lib_engine_api_http_55789ed73940 = nil
+local src_lib_engine_api_i18n_55789ed73390 = nil
+local src_lib_engine_api_key_55789ed67430 = nil
+local src_lib_engine_api_log_55789ed6ec50 = nil
+local src_lib_engine_api_math_55789ed97690 = nil
+local src_lib_engine_api_array_55789ed6a870 = nil
+local src_lib_engine_api_media_55789ed5bbd0 = nil
+local src_lib_engine_draw_fps_55789edb30e0 = nil
+local src_lib_engine_draw_text_55789ed7cb30 = nil
+local src_lib_engine_draw_poly_55789ed758d0 = nil
+local src_lib_engine_raw_memory_55789ed6cc30 = nil
+local src_lib_protocol_http_callback_55789ed506b0 = nil
+local src_lib_object_root_55789ed7d4c0 = nil
+local src_lib_object_color_55789edbd130 = nil
+local src_lib_object_std_55789ed51260 = nil
+local src_lib_util_pipeline_55789ed7d870 = nil
+local src_lib_util_decorator_55789ed6a3c0 = nil
+local src_lib_util_http_55789eda0210 = nil
+local function main_55789ed4b7f0()
+local version = src_version_55789ed81210()
+local zeebo_module = src_lib_common_module_55789ed58c40()
+local engine_encoder = src_lib_engine_api_encoder_55789ed92660()
+local engine_game = src_lib_engine_api_app_55789eda8c90()
+local engine_hash = src_lib_engine_api_hash_55789ed5fba0()
+local engine_http = src_lib_engine_api_http_55789ed73940()
+local engine_i18n = src_lib_engine_api_i18n_55789ed73390()
+local engine_key = src_lib_engine_api_key_55789ed67430()
+local engine_log = src_lib_engine_api_log_55789ed6ec50()
+local engine_math = src_lib_engine_api_math_55789ed97690()
+local engine_array = src_lib_engine_api_array_55789ed6a870()
+local engine_media = src_lib_engine_api_media_55789ed5bbd0()
+local engine_draw_fps = src_lib_engine_draw_fps_55789edb30e0()
+local engine_draw_text = src_lib_engine_draw_text_55789ed7cb30()
+local engine_draw_poly = src_lib_engine_draw_poly_55789ed758d0()
+local engine_raw_memory = src_lib_engine_raw_memory_55789ed6cc30()
+local callback_http = src_lib_protocol_http_callback_55789ed506b0()
+local application_default = src_lib_object_root_55789ed7d4c0()
+local color = src_lib_object_color_55789edbd130()
+local std = src_lib_object_std_55789ed51260()
 local application = application_default
 local engine = {
 keyboard = function(a, b, c, d) end,
@@ -53,6 +58,7 @@ get_secret = native_system_get_secret,
 get_language = native_system_get_language
 }
 local cfg_media = {
+bootstrap=native_media_bootstrap,
 position=native_media_position,
 resize=native_media_resize,
 pause=native_media_pause,
@@ -74,8 +80,18 @@ local cfg_text = {
 font_previous = native_text_font_previous
 }
 local cfg_http = {
-ssl = native_http_has_ssl,
-handler = native_http_handler
+install = native_http_install,
+handler = native_http_handler,
+has_ssl = native_http_has_ssl,
+has_callback = native_http_has_callback,
+force = native_http_force_protocol
+}
+local cfg_log = {
+fatal = native_log_fatal,
+error = native_log_error,
+warn = native_log_warn,
+info = native_log_info,
+debug = native_log_debug
 }
 local cfg_base64 = {
 decode = native_base64_decode,
@@ -108,6 +124,12 @@ end
 function native_callback_keyboard(key, value)
 engine.keyboard(std, engine, key, value)
 end
+function native_callback_http(id, key, data)
+if cfg_http.has_callback then
+return callback_http.func(engine['http_requests'][id], key, data)
+end
+return nil
+end
 function native_callback_init(width, height, game_lua)
 application = zeebo_module.loadgame(game_lua)
 if application then
@@ -126,7 +148,9 @@ std.draw.color=native_draw_color
 std.draw.font=native_draw_font
 std.draw.rect=native_draw_rect
 std.draw.line=native_draw_line
-std.draw.image=native_draw_image
+std.draw.image=native_image_draw
+std.image.load=native_image_load
+std.image.draw=native_image_draw
 std.text.print=native_text_print
 std.text.mensure=native_text_mensure
 std.text.font_size=native_text_font_size
@@ -146,7 +170,9 @@ zeebo_module.require(std, application, engine)
 :package('@draw.text', engine_draw_text, cfg_text)
 :package('@draw.poly', engine_draw_poly, cfg_poly)
 :package('@color', color)
+:package('@log', engine_log, cfg_log)
 :package('math', engine_math.clib)
+:package('math.wave', engine_math.wave)
 :package('math.random', engine_math.clib_random)
 :package('http', engine_http, cfg_http)
 :package('base64', engine_encoder, cfg_base64)
@@ -154,7 +180,10 @@ zeebo_module.require(std, application, engine)
 :package('xml', engine_encoder, cfg_xml)
 :package('i18n', engine_i18n, cfg_system)
 :package('hash', engine_hash, cfg_system)
-:package('media', engine_media, cfg_media)
+:package('media.video', engine_media, cfg_media)
+:package('media.audio', engine_media, cfg_media)
+:package('mock.video', engine_media)
+:package('mock.audio', engine_media)
 :run()
 application.data.width, std.app.width = width, width
 application.data.height, std.app.height = height, height
@@ -172,13 +201,13 @@ version=version
 }
 return P
 end
-src_version_561fa16ca630 = function()
-return '0.0.18'
+src_version_55789ed81210 = function()
+return '0.0.20'
 end
 --
-src_lib_common_module_561fa16cab70 = function()
-local zeebo_pipeline = src_lib_util_pipeline_561fa16c26b0()
-local application_default = src_lib_object_root_561fa16cb030()
+src_lib_common_module_55789ed58c40 = function()
+local zeebo_pipeline = src_lib_util_pipeline_55789ed7d870()
+local application_default = src_lib_object_root_55789ed7d4c0()
 local function default(application, defaults)
 if not application then return nil end
 local index = 1    
@@ -376,7 +405,7 @@ require = require
 return P
 end
 --
-src_lib_engine_api_encoder_561fa16cb2c0 = function()
+src_lib_engine_api_encoder_55789ed92660 = function()
 local function install(std, engine, library, name)
 std = std or {}
 std[name] = {
@@ -391,8 +420,8 @@ install=install
 return P
 end
 --
-src_lib_engine_api_app_561fa16cff00 = function()
-local util_decorator = src_lib_util_decorator_561fa16bfce0()
+src_lib_engine_api_app_55789eda8c90 = function()
+local util_decorator = src_lib_util_decorator_55789ed6a3c0()
 local function reset(std, engine)
 if std.node then
 std.bus.emit('exit')
@@ -432,7 +461,7 @@ install=install
 return P
 end
 --
-src_lib_engine_api_hash_561fa16d0530 = function()
+src_lib_engine_api_hash_55789ed5fba0 = function()
 local function djb2(digest)
 local index = 1
 local hash = 5381
@@ -458,8 +487,8 @@ install = install
 return P
 end
 --
-src_lib_engine_api_http_561fa16d0b50 = function()
-local zeebo_pipeline = src_lib_util_pipeline_561fa16c26b0()
+src_lib_engine_api_http_55789ed73940 = function()
+local zeebo_pipeline = src_lib_util_pipeline_55789ed7d870()
 local function fast(self)
 self.speed = '_fast'
 return self
@@ -492,13 +521,24 @@ local function http_error(self, handler_func)
 self.error_handler = handler_func
 return self
 end
-local function request(method, std, engine, protocol_handler)
+local function request(method, std, engine, protocol)
 local callback_handler = function()
+if std.node then
 std.node.emit(engine.current, 'http')
+elseif engine.current.callbacks.http then
+engine.current.callbacks.http(std, engine.current.data)
+end
 end
 return function (url)
+if protocol.has_callback then
+engine.http_count = engine.http_count + 1
+end
+if protocol.force then
+url = url:gsub("^[^:]+://", protocol.force.."://")
+end
 local game = engine.current.data
 local self = {
+id = engine.http_count,
 url = url,
 speed = '',
 method = method,
@@ -507,12 +547,9 @@ header_list = {},
 header_dict = {},
 param_list = {},
 param_dict = {},
-callback_handler = callback_handler,
 success_handler = function (std, game) end,
 failed_handler = function (std, game) end,
 error_handler = function (std, game) end,
-std = std,
-game = game,
 fast = fast,
 body = body,
 param = param,
@@ -521,7 +558,6 @@ success = success,
 failed = failed,
 error = http_error,
 run = zeebo_pipeline.run,
-protocol_handler = protocol_handler
 }
 self.promise = function()
 zeebo_pipeline.stop(self)
@@ -530,29 +566,34 @@ self.resolve = function()
 zeebo_pipeline.resume(self)
 end
 self.set = function (key, value)
-self.std.http[key] = value
+std.http[key] = value
 end
 self.pipeline = {
 function()
-self:protocol_handler()
+if protocol.has_callback then engine.http_requests[self.id] = self end
+protocol.handler(self, self.id)
 end,
 function()
-self.callback_handler(self.std, self.game)
-if self.std.http.ok then
-self.success_handler(self.std, self.game)
-elseif self.std.http.error or not self.std.http.status then
-self.error_handler(self.std, self.game)
+callback_handler(std, game)
+if std.http.ok then
+self.success_handler(std, game)
+elseif std.http.error then
+self.error_handler(std, game)
+elseif not std.http.status then
+self.set('error', 'missing protocol response')
+self.error_handler(std, game)
 else
-self.failed_handler(self.std, self.game)
+self.failed_handler(std, game)
 end
 end,
 function ()
-self.std.http.ok = nil
-self.std.http.body = nil
-self.std.http.error = nil
-self.std.http.status = nil
+std.http.ok = nil
+std.http.body = nil
+std.http.error = nil
+std.http.status = nil
 end,
 function()
+if protocol.has_callback then engine.http_requests[self.id] = nil end
 zeebo_pipeline.reset(self)
 end
 }
@@ -560,23 +601,21 @@ return self
 end
 end
 local function install(std, engine, protocol)
-local protocol_handler = protocol and protocol.handler
-if not protocol_handler then
-error('missing protocol handler')
+assert(protocol and protocol.handler, 'missing protocol handler')
+if protocol.has_callback then
+engine.http_count = 0
+engine.http_requests = {}
 end
 std.http = std.http or {}
-std.http.get=request('GET', std, engine, protocol_handler)
-std.http.head=request('HEAD', std, engine, protocol_handler)
-std.http.post=request('POST', std, engine, protocol_handler)
-std.http.put=request('PUT', std, engine, protocol_handler)
-std.http.delete=request('DELETE', std, engine, protocol_handler)
-std.http.patch=request('PATCH', std, engine, protocol_handler)
+std.http.get=request('GET', std, engine, protocol)
+std.http.head=request('HEAD', std, engine, protocol)
+std.http.post=request('POST', std, engine, protocol)
+std.http.put=request('PUT', std, engine, protocol)
+std.http.delete=request('DELETE', std, engine, protocol)
+std.http.patch=request('PATCH', std, engine, protocol)
 if protocol.install then
 protocol.install(std, engine)
 end
-return {
-std={http=std.http}
-}
 end
 local P = {
 install=install
@@ -584,7 +623,7 @@ install=install
 return P
 end
 --
-src_lib_engine_api_i18n_561fa16d10f0 = function()
+src_lib_engine_api_i18n_55789ed73390 = function()
 local language = 'en-US'
 local language_default = 'en-US'
 local language_list = {}
@@ -676,7 +715,7 @@ install=install
 return P
 end
 --
-src_lib_engine_api_key_561fa16d1700 = function()
+src_lib_engine_api_key_55789ed67430 = function()
 local function real_key(std, engine, rkey, rvalue)
 local value = rvalue == 1 or rvalue == true
 local key = engine.key_bindings[rkey] or (std.key.axis[rkey] and rkey)
@@ -691,6 +730,8 @@ std.key.axis.y = std.key.axis.down - std.key.axis.up
 end
 std.bus.emit('key')
 end
+local a = std.key.axis
+std.key.press.any = (a.left + a.right + a.down + a.up + a.a + a.b + a.c + a.d + a.menu) > 0
 end
 local function real_keydown(std, engine, key)
 real_key(std, engine, key, 1)
@@ -714,7 +755,54 @@ install = install
 return P
 end
 --
-src_lib_engine_api_math_561fa16c5900 = function()
+src_lib_engine_api_log_55789ed6ec50 = function()
+local util_decorator = src_lib_util_decorator_55789ed6a3c0()
+local logging_types = {
+'none', 'fatal', 'error', 'warn', 'debug', 'info'
+}
+local function level(engine, lpf, lpn, level)
+local l = lpf[level] or lpn[level] or level
+if type(l) ~= 'number' or l <= 0 or l > #logging_types then
+error('logging level not exist: '..tostring(level)) 
+end
+engine.loglevel = l
+end
+local function init(std, engine, printers)
+local index = 1
+local level_per_func = {}
+local level_per_name = {}
+while index <= #logging_types do
+local ltype = logging_types[index]
+local lfunc = function() end
+if index > 1 and printers[ltype] then
+lfunc = (function (level)
+return function(message)
+if engine.loglevel >= level then
+printers[ltype](message)
+end
+end
+end)(index - 1)
+end
+level_per_func[lfunc] = index - 1
+level_per_name[ltype] = index - 1
+std.log[ltype] = lfunc
+index = index + 1
+end
+std.log.level = util_decorator.prefix3(engine, level_per_func, level_per_name, level)
+end
+local function install(std, engine, printers)
+std.log = std.log or {}
+engine.loglevel = #logging_types
+std.log.init = util_decorator.prefix2(std, engine, init)
+std.log.init(printers)
+end
+local P = {
+install = install
+}
+return P
+end
+--
+src_lib_engine_api_math_55789ed97690 = function()
 local function abs(value)
 if value < 0 then
 return -value
@@ -793,8 +881,31 @@ index = index + 1
 end
 return min_value
 end
+local function sine(t, freq)
+return math.pi and math.sin(2 * math.pi * freq * t) or 1
+end
+local function ramp(t, freq, ratio)
+t = (t / 2) % (1 / freq) * freq
+if t < ratio then
+return 2 * t / ratio - 1
+else
+return (2 * t - ratio - 1) / (ratio - 1)
+end
+end
+local function saw(t, freq)
+return ramp(t, freq, 1)
+end
+local function triangle(t, freq)
+return ramp(t, freq, 1/2)
+end
+local function rect(t, freq, duty)
+duty = 1 - duty * 2
+return saw(t, freq) > duty and 1 or -1
+end
+local function square(t, freq)
+return rect(t, freq, 1/2)
+end
 local function install(std)
-std = std or {}
 std.math = std.math or {}
 std.math.abs=abs
 std.math.clamp=clamp
@@ -807,10 +918,15 @@ std.math.lerp=lerp
 std.math.map=map
 std.math.max=max
 std.math.min=min
-return std.math
+end
+local function install_wave(std)
+std.math = std.math or {}
+std.math.sine=sine
+std.math.saw=saw
+std.math.square=square
+std.math.triangle=triangle
 end
 local function install_clib(std)
-std = std or {}
 std.math = std.math or {}
 std.math.acos=math.acos
 std.math.asin=math.asin
@@ -837,20 +953,20 @@ std.math.sinh=math.sinh
 std.math.sqrt=math.sqrt
 std.math.tan=math.tan
 std.math.tanh=math.tanh
-return std.math
 end
 local function install_clib_random(std)
-std = std or {}
 std.math = std.math or {}
 std.math.random = function(a, b)
 a = a and math.floor(a)
 b = b and math.floor(b)
 return math.random(a, b)
 end
-return std.math
 end
 local P = {
 install = install,
+wave = {
+install = install_wave
+},
 clib = {
 install = install_clib
 },
@@ -861,8 +977,8 @@ install = install_clib_random
 return P;
 end
 --
-src_lib_engine_api_array_561fa16c1450 = function()
-local util_decorator = src_lib_util_decorator_561fa16bfce0()
+src_lib_engine_api_array_55789ed6a870 = function()
+local util_decorator = src_lib_util_decorator_55789ed6a3c0()
 local function array_map(array, func)
 local res = {}
 local index = 1
@@ -1004,6 +1120,7 @@ return self
 end
 local function install(std, engine, library, name)
 local lib = std[name] or {}
+lib.map = array_map
 lib.filter = array_filter
 lib.unique = array_unique
 lib.each = array_foreach
@@ -1022,68 +1139,41 @@ install = install
 return P
 end
 --
-src_lib_engine_api_media_561fa16cce10 = function()
-local util_decorator = src_lib_util_decorator_561fa16bfce0()
-local function media_add(func, self, src)
-func(self.id - 1, src)
+src_lib_engine_api_media_55789ed5bbd0 = function()
+local function media_create(node, channels, handler)
+local decorator = function(func)
+func = func or function() end
+return function(self, a, b, c)
+func(0, a, b, c)
 return self
 end
-local function media_play(func, self)
-func(self.id - 1)
-return self
-end
-local function media_pause(func, self)
-func(self.id - 1)
-return self
-end
-local function media_resize(func, self, width, height)
-func(self.id - 1, width, height)
-return self
 end
-local function media_position(func, self, pos_x, pos_y)
-func(self.id - 1, pos_x, pos_y)
-return self
-end
-local channels = {}
-local function media_channel(std, handler)
-return function(id)
-id = id or 1
-if 0 >= id or id > 8 then
-error('Please, do not do that!')
-end
-if not channels[id] then
-channels[id] = {
-id = id,
-add = util_decorator.prefix1(handler.load, media_add),
-play = util_decorator.prefix1(handler.play, media_play),
-pause = util_decorator.prefix1(handler.pause, media_pause),
-resize = util_decorator.prefix1(handler.resize, media_resize),
-position = util_decorator.prefix1(handler.position, media_position)
+local self = { 
+src = decorator(handler.source),
+play = decorator(handler.play),
+pause = decorator(handler.pause),
+resume = decorator(handler.resume),
+stop = decorator(handler.stop),
+position = decorator(handler.position),
+resize = decorator(handler.resize),
+node = node,
+apply = function() end
 }
-if std.node then
-channels[id].node = std.node.load({})
-channels[id].apply = function()
-local node = channels[id].node
-local depth = 0
-local offset_x = 0
-local offset_y = 0
-while node and depth < 100 do
-offset_x = offset_x + node.config.offset_x
-offset_y = offset_y + node.config.offset_y
-node = node.config.parent
-depth = depth + 1
-end
-media_position(handler.position, channels[id], offset_x, offset_y)
-media_resize(handler.resize, channels[id], channels[id].node.data.width, channels[id].node.data.height)
-end
+return function()
+return self
 end
 end
-return channels[id]
+local function install(std, engine, handler, name)
+std.media = std.media or {}
+local mediatype = name:match('%w+%.(%w+)')
+if not std.media[mediatype] then
+local channels = handler.bootstrap and handler.bootstrap(mediatype)
+if (not channels or channels == 0) and handler.bootstrap then
+error('media '..mediatype..' is not supported!')
 end
+local node = std.node and std.node.load({})
+std.media[mediatype] = media_create(node, channels, handler)
 end
-local function install(std, engine, handlers)
-std.media = std.media or {}
-std.media.video = media_channel(std, handlers)
 end
 local P = {
 install=install
@@ -1091,7 +1181,7 @@ install=install
 return P
 end
 --
-src_lib_engine_draw_fps_561fa16c6900 = function()
+src_lib_engine_draw_fps_55789edb30e0 = function()
 local function draw_fps(std, engine, show, pos_x, pos_y)
 if show < 1 then return end
 local x = engine.current.config.offset_x + pos_x
@@ -1143,8 +1233,8 @@ install=install
 return P
 end
 --
-src_lib_engine_draw_text_561fa16c8d50 = function()
-local util_decorator = src_lib_util_decorator_561fa16bfce0()
+src_lib_engine_draw_text_55789ed7cb30 = function()
+local util_decorator = src_lib_util_decorator_55789ed6a3c0()
 local function text_put(std, engine, font_previous, pos_x, pos_y, text, size)
 size = size or 2
 local hem = engine.current.data.width / 80
@@ -1171,7 +1261,7 @@ install=install
 return P
 end
 --
-src_lib_engine_draw_poly_561fa16ca270 = function()
+src_lib_engine_draw_poly_55789ed758d0 = function()
 local function decorator_poo(object, func)
 if not object or not func then return func end
 return function(a, b, c, d)
@@ -1278,21 +1368,25 @@ install=install
 return P
 end
 --
-src_lib_engine_raw_memory_561fa16caab0 = function()
+src_lib_engine_raw_memory_55789ed6cc30 = function()
 local memory_dict_unload = {}
 local memory_dict = {}
 local memory_list = {}
-local function cache(key, load_func, unload_func)
-if memory_dict[key] then
+local function cache_get(key)
 return memory_dict[key]
 end
-if not load_func then
-return nil
-end
+local function cache_set(key, load_func, unload_func)
 local value = load_func()
 memory_list[#memory_list + 1] = key
 memory_dict_unload[key] = unload_func
 memory_dict[key] = value
+end
+local function cache(key, load_func, unload_func)
+local value = cache_get(key)
+if value == nil then
+cache_set(key, load_func, unload_func)
+value = cache_get(key)
+end    
 return value
 end
 local function unset(key)
@@ -1315,6 +1409,8 @@ local function install(std)
 std = std or {}
 std.mem = std.mem or {}
 std.mem.cache = cache
+std.mem.cache_get = cache_get
+std.mem.cache_set = cache_set
 std.mem.unset = unset
 std.mem.gc_clear_all = gc_clear_all
 return {
@@ -1327,7 +1423,75 @@ install=install
 return P
 end
 --
-src_lib_object_root_561fa16cb030 = function()
+src_lib_protocol_http_callback_55789ed506b0 = function()
+local http_util = src_lib_util_http_55789eda0210()
+local callbacks = {
+['async-promise'] = function(self)
+return self:promise()
+end,
+['async-resolve'] = function(self)
+return self:resolve()
+end,
+['get-url'] = function(self)
+return self.url
+end,
+['get-fullurl'] = function(self)
+return self.url..http_util.url_search_param(self.param_list, self.param_dict)
+end,
+['get-method'] = function(self)
+return self.method
+end,
+['get-body'] = function(self)
+return self.body_content
+end,
+['get-param-count'] = function(self)
+return #self.param_list
+end,
+['get-param-name'] = function(self, data)
+return self.param_list[self.data]
+end,
+['get-param-data'] = function(self, data)
+return self.param_dict[self.data] or self.param_dict[self.param_list[self.data]]
+end,
+['get-header-count'] = function(self)
+return #self.header_list
+end,
+['get-header-name'] = function(self, data)
+return self.header_list[self.data]
+end,
+['get-header-data'] = function(self, data)
+return self.heeader_dict[self.data] or self.heeader_dict[self.header_list[self.data]]
+end,
+['set-status'] = function(self, data)
+self.set('status', data)
+self.set('ok', http_util.is_ok(data))
+end,
+['set-error'] = function(self, data)
+self.set('error', data)
+end,
+['set-ok'] = function(self, data)
+self.set('ok', data)
+end,
+['set-body'] = function(self, data)
+self.set('body', data)
+end,
+['add-body-data'] = function(self, data, std)
+self.set('body', (std.http.body or '')..data)
+end    
+}
+local function native_http_callback(self, evt, data, std)
+if not callbacks[evt] then
+error('http evt '..evt..' not exist!')
+end
+return callbacks[evt](self, data, std)
+end
+local P = {
+func = native_http_callback
+}
+return P
+end
+--
+src_lib_object_root_55789ed7d4c0 = function()
 local P = {
 data={
 width=1280,
@@ -1357,61 +1521,34 @@ callbacks={
 return P;
 end
 --
-src_lib_object_color_561fa16d0260 = function()
-local white = 0xFFFFFFFF
-local lightgray = 0xC8CCCCFF
-local gray = 0x828282FF
-local darkgray = 0x505050FF
-local yellow = 0xFDF900FF
-local gold = 0xFFCB00FF
-local orange = 0xFFA100FF
-local pink = 0xFF6DC2FF
-local red = 0xE62937FF
-local maroon = 0xBE2137FF
-local green = 0x00E430FF
-local lime = 0x009E2FFF
-local darkgreen = 0x00752CFF
-local skyblue = 0x66BFFFFF
-local blue = 0x0079F1FF
-local darkblue = 0x0052ACFF
-local purple = 0xC87AFFFF
-local violet = 0x873CBEFF
-local darkpurple = 0x701F7EFF
-local beige = 0xD3B083FF
-local brown = 0x7F6A4FFF
-local darkbrown = 0x4C3F2FFF
-local black = 0x000000FF
-local blank = 0x00000000
-local magenta = 0xFF00FFFF
+src_lib_object_color_55789edbd130 = function()
 local function install(std)
-std = std or {}
 std.color = std.color or {}
-std.color.white = white
-std.color.lightgray = lightgray
-std.color.gray = gray
-std.color.darkgray = darkgray
-std.color.yellow = yellow
-std.color.gold = gold
-std.color.orange = orange
-std.color.pink = pink
-std.color.red = red
-std.color.maroon = maroon
-std.color.green = green
-std.color.lime = lime
-std.color.darkgreen = darkgreen
-std.color.skyblue = skyblue
-std.color.blue = blue
-std.color.darkblue = darkblue
-std.color.purple = purple
-std.color.violet = violet
-std.color.darkpurple = darkpurple
-std.color.beige = beige
-std.color.brown = brown
-std.color.darkbrown = darkbrown
-std.color.black = black
-std.color.blank = blank
-std.color.magenta = magenta
-return std.color
+std.color.white = 0xFFFFFFFF
+std.color.lightgray = 0xC8CCCCFF
+std.color.gray = 0x828282FF
+std.color.darkgray = 0x505050FF
+std.color.yellow = 0xFDF900FF
+std.color.gold = 0xFFCB00FF
+std.color.orange = 0xFFA100FF
+std.color.pink = 0xFF6DC2FF
+std.color.red = 0xE62937FF
+std.color.maroon = 0xBE2137FF
+std.color.green = 0x00E430FF
+std.color.lime = 0x009E2FFF
+std.color.darkgreen = 0x00752CFF
+std.color.skyblue = 0x66BFFFFF
+std.color.blue = 0x0079F1FF
+std.color.darkblue = 0x0052ACFF
+std.color.purple = 0xC87AFFFF
+std.color.violet = 0x873CBEFF
+std.color.darkpurple = 0x701F7EFF
+std.color.beige = 0xD3B083FF
+std.color.brown = 0x7F6A4FFF
+std.color.darkbrown = 0x4C3F2FFF
+std.color.black = 0x000000FF
+std.color.blank = 0x00000000
+std.color.magenta = 0xFF00FFFF
 end
 local P = {
 install = install
@@ -1419,7 +1556,7 @@ install = install
 return P
 end
 --
-src_lib_object_std_561fa16c9dc0 = function()
+src_lib_object_std_55789ed51260 = function()
 local P = {
 milis = 0,
 delta = 0,
@@ -1442,6 +1579,10 @@ font_size = function() end,
 font_name = function() end,
 font_default = function() end
 },
+image = {
+load = function() end,
+draw = function() end
+},
 app = {
 width = 1280,
 height = 720,
@@ -1473,14 +1614,15 @@ right=false,
 a=false,
 b=false,
 c=false,
-d=false
+d=false,
+any=false
 }
 }
 }
 return P;
 end
 --
-src_lib_util_pipeline_561fa16c26b0 = function()
+src_lib_util_pipeline_55789ed7d870 = function()
 local function pipe(self)
 return function()
 self:run()
@@ -1530,7 +1672,7 @@ run=run
 return P
 end
 --
-src_lib_util_decorator_561fa16bfce0 = function()
+src_lib_util_decorator_55789ed6a3c0 = function()
 local function decorator_prefix3(zig, zag, zom, func)
 return function (a, b, c, d, e, f)
 return func(zig, zag, zom, a, b, c, d, e, f)
@@ -1569,15 +1711,172 @@ local y = object.offset_y + b
 return func(x, y, c, d, e, f)
 end
 end
+local function table_prefix1(prefix, fn_table)
+local new_table = {}
+for name, fn in pairs(fn_table) do
+new_table[name] = decorator_prefix1(prefix, fn)
+end
+return new_table
+end
 local P = {
 offset_xy1 = decorator_offset_xy1,
 offset_xy2 = decorator_offset_xy2,
 offset_xyxy1 = decorator_offset_xyxy1,
 prefix3 = decorator_prefix3,
 prefix2 = decorator_prefix2,
-prefix1 = decorator_prefix1
+prefix1 = decorator_prefix1,
+prefix1_t = table_prefix1
 }
 return P
 end
 --
-return main_561fa16ca3f0()
+src_lib_util_http_55789eda0210 = function()
+local function is_ok(status)
+return (status and 200 <= status and status < 300) or false
+end
+local function is_ok_header(header)
+local status = tonumber(header:match('HTTP/%d.%d (%d%d%d)'))
+local ok = status and is_ok(status) or false
+return ok, status
+end
+local function is_redirect(status)
+return (status and 300 <= status and status < 400) or false
+end
+local function url_search_param(param_list, param_dict)
+local index, params = 1, ''
+while param_list and param_dict and index <= #param_list do
+local param = param_list[index]
+local value = param_dict[param]
+if #params == 0 then
+params = params..'?'
+else
+params = params..'&'
+end
+params = params..param..'='..(value or '')
+index = index + 1
+end
+return params
+end
+local function create_request(method, uri)
+local self = {
+body_content = '',
+header_list = {},
+header_dict = {},
+header_imutable = {},
+print_http_status = true
+}
+self.add_body_content = function (body)
+self.body_content = self.body_content..(body or '')
+return self
+end
+self.add_imutable_header = function (header, value, cond)
+if cond == false then return self end
+if self.header_imutable[header] == nil then
+self.header_list[#self.header_list + 1] = header
+self.header_dict[header] = value
+elseif self.header_imutable[header] == false then
+self.header_dict[header] = value
+end
+self.header_imutable[header] = true
+return self
+end
+self.add_mutable_header = function (header, value, cond)
+if cond == false then return self end
+if self.header_imutable[header] == nil then
+self.header_list[#self.header_list + 1] = header
+self.header_imutable[header] = false
+self.header_dict[header] = value
+end
+return self
+end
+self.add_custom_headers = function(header_list, header_dict)
+local index = 1
+while header_list and #header_list >= index do
+local header = header_list[index]
+local value = header_dict[header]
+if self.header_imutable[header] == nil then
+self.header_list[#self.header_list + 1] = header
+self.header_imutable[header] = false
+self.header_dict[header] = value
+elseif self.header_imutable[header] == false then
+self.header_dict[header] = value
+end
+index = index + 1
+end
+return self
+end
+self.not_status = function()
+self.print_http_status = false
+return self
+end
+self.to_http_protocol = function ()
+local index = 1
+local request = method..' '..uri..' HTTP/1'..'.1\r\n'
+while index <= #self.header_list do
+local header = self.header_list[index]
+local value = self.header_dict[header]
+request = request..header..': '..value..'\r\n'
+index = index + 1
+end
+request = request..'\r\n'
+if method ~= 'GET' and method ~= 'HEAD' and #self.body_content > 0 then
+request = request..self.body_content..'\r\n\r\n'
+end
+return request, function() end
+end
+self.to_curl_cmd = function ()
+local index = 1
+local request = 'curl -L -'..'-silent -'..'-insecure '
+if self.print_http_status then
+request = request..'-w "\n%{http_code}" '
+end
+if method == 'HEAD' then
+request = request..'-'..'-HEAD '
+else
+request = request..'-X '..method..' '
+end
+while index <= #self.header_list do
+local header = self.header_list[index]
+local value = self.header_dict[header]
+request = request..'-H "'..header..': '..value..'" '
+index = index + 1
+end
+if method ~= 'GET' and method ~= 'HEAD' and #self.body_content > 0 then
+request = request..'-d \''..self.body_content..'\' '
+end
+request = request..uri
+return request, function() end
+end
+self.to_wget_cmd = function ()
+local request = 'wget -'..'-quiet -'..'-output-document=-'
+if method == 'HEAD' then
+request = request..' -'..'-method=HEAD'
+elseif method ~= 'GET' then
+request = request..' -'..'-method='..method
+end
+for index, header in ipairs(self.header_list) do
+local value = self.header_dict[header]
+if value then
+local escaped_value = value:gsub('"', '\\"')
+request = request..' -'..'-header="'..header..': '..escaped_value..'"'
+end
+end
+if method ~= 'GET' and method ~= 'HEAD' and #self.body_content > 0 then
+local escaped_body = self.body_content:gsub('"', '\\"')
+request = request..' -'..'-body-data="'..escaped_body..'"'
+end
+request = request..' '..uri
+return request, function() end
+end
+return self
+end
+return {
+is_ok=is_ok,
+is_ok_header=is_ok_header,
+is_redirect=is_redirect,
+url_search_param=url_search_param,
+create_request=create_request
+}
+end
+--
+return main_55789ed4b7f0()

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gamely/gly-engine-lite",
-    "version": "0.0.18",
+    "version": "0.0.20",
     "author": "RodrigoDornelles",
     "license": "Apache-2.0",
     "homepage": "https://docs.gamely.com.br",
@@ -8,7 +8,8 @@
     "funding": "https://github.com/sponsors/RodrigoDornelles",
     "bugs": "https://github.com/gamelly/gly-engine/issues",
     "description": "Game Engine written in 100% lua that runs in a vacuum.",
-    "main": "dist/index.lua",
+    "main": "dist/main.lua",
+    "types": "types/main.d.ts",
     "keywords": [
         "game engine",
         "game",

package/types/main.d.ts

@@ -0,0 +1,4 @@
+declare module '@gamely/gly-engine-lite' {
+ const content: string;
+ export default content;
+}