termgui 0.0.4 → 0.0.5

data/src/tco/tco_termgui.rb

@@ -1,30 +0,0 @@
-require_relative 'colouring'
-require_relative 'config'
-
-module TermGui
-  @colouring_config = Tco::Config.new
-  @colouring = Tco::Colouring.new @colouring_config
-
-  def self.open_style(style, colouring = @colouring)
-    s = colouring.decorate('__', style)
-    s = s.slice(0, s.length - 4 - 2)
-    s
-  end
-
-  def self.close_style(_colouring = @colouring)
-    @colouring.decorate('', TermGui::Style.new(fg: 'red', bg: 'red', bold: true, underline: true))
-  end
-
-  def self.print(s, style)
-    @colouring.decorate(s, style)
-  end
-
-  def self.fast_colouring(value)
-    Tco::Colour.fast = value
-    @colouring.palette.reset_cache
-  end
-
-  def self.to_rgb(value)
-    @colouring.get_colour_instance(value).rgb
-  end
-end

data/src/termgui.rb

@@ -1,29 +0,0 @@
-require_relative 'emitter'
-require_relative 'event'
-require_relative 'input'
-require_relative 'node'
-require_relative 'renderer'
-require_relative 'style'
-require_relative 'screen'
-require_relative 'tco/tco_termgui'
-require_relative 'element'
-require_relative 'focus'
-require_relative 'image'
-require_relative 'action'
-require_relative 'cursor'
-require_relative 'enterable'
-require_relative 'geometry'
-require_relative 'util/css'
-require_relative 'widget/button'
-require_relative 'widget/col'
-require_relative 'widget/inputbox'
-require_relative 'widget/image'
-require_relative 'widget/inline'
-require_relative 'widget/checkbox'
-require_relative 'widget/selectbox'
-require_relative 'widget/input_number'
-require_relative 'widget/label'
-require_relative 'widget/modal'
-require_relative 'widget/row'
-require_relative 'editor/editor_base_handlers'
-require_relative 'editor/editor_base'

data/src/util.rb

@@ -1,110 +0,0 @@
-require 'json'
-
-def json_parse(str)
-  JSON.parse(str)
-end
-
-def json_stringify(obj)
-  JSON.generate(obj)
-end
-
-# TODO: why is it so hard in ruby to access an outer local variable from a method ? I needed to create a
-# module and a wrapper for somethig very trivial
-
-module Util
-  @uc = 0
-  def self.unique(s = '')
-    @uc += 1
-    s + @uc.to_s
-  end
-end
-
-def to_array(v)
-  v.is_a?(Array) ? v : [v]
-end
-
-def unique(s = '')
-  Util.unique(s)
-end
-
-# TODO: hack because \n chars are not printed with puts or print:
-def print_string(str)
-  str.split('\n').map { |s| puts s || '' }
-end
-
-def print_ms(t0)
-  "#{((Time.now - t0) * 1000).to_i} ms"
-end
-
-def parse_integer(s, default = nil)
-  Integer(s)
-rescue StandardError
-  default
-end
-
-def parse_float(s, default = nil)
-  Float(s)
-rescue StandardError
-  default
-end
-
-# returns true if given value is between 0.0 and 1.0
-def is_percent(val)
-  val && val > 0 && val < 1
-end
-
-def unquote(s)
-  s[1..s.length - 1]
-end
-
-def next_tick
-  sleep 0.0000001
-end
-
-def random_int(min = 0, max = 10)
-  (min..max).to_a.sample
-end
-
-def random_float(min = 0.0, max = 1.0)
-  rand * (max - min) + min
-end
-
-CHARS = ('a'..'z').to_a.concat(('A'..'Z').to_a).push('_', '-', '@', '!', '#', '$', '%', '^', '&', '*', '=', '+')
-
-def random_char
-  CHARS.sample
-end
-
-def random_color
-  [random_int(0, 255), random_int(0, 255), random_int(0, 255)]
-end
-
-# similar to JS Array.prototype.some
-def some(array, predicate)
-  i = 0
-  value = nil
-  while i < array.length
-    e = array[i]
-    value = predicate.call e
-    if value
-      value = array[i]
-      break
-    else
-      value = nil
-    end
-    i += 1
-  end
-  value
-end
-
-# TODO: this is the same as event.rb Event. Move Event classes to individual - non dependency file
-module TermGui
-  class Event
-    # @return {String}
-    attr_reader :name
-    # @param {String} name
-    def initialize(name)
-      @name = name
-    end
-end
-end

data/src/util/css.rb

@@ -1,98 +0,0 @@
-# css like language parser
-# TODO: move this to its own project
-
-module TermGui
-  # given a string like `foo {bg: red; padding-top: 3} .bar .primary {}`
-  # Rules:
-  #  * values cannot contain any of the following chars: `:;{}`
-  #  * No inmediate children ('>') supported. Example, `a b` is supported. `a>b` is not supported.
-  class CSSParser
-    def parse(code)
-      rules = parse_rules code
-      rules = parse_rules_properties rules
-      rules = parse_rules_selectors rules
-      rules
-    end
-
-    def parse_rules(code)
-      code.split('}').map do |rule|
-        a = rule.split('{')
-        throw "Syntax error in rule '#{rule}'" if a.length != 2
-        {
-          selector: a[0].strip,
-          body: a[1].strip
-        }
-      end
-    end
-
-    # given rules are the output of `parse_rules`. It will return a similar object but for each rule, instead `body` string have name-value `properies`
-    def parse_rules_properties(rules)
-      rules.map do |rule|
-        properties = rule[:body].split(';').map(&:strip)
-        properties = properties.map do |property|
-          a = property.split(':').map(&:strip)
-          throw "Syntax error in property '#{property}', rule: '#{rule}'" if a.length != 2
-          {
-            name: a[0],
-            value: a[1]
-          }
-        end
-        {
-          selector: rule[:selector],
-          properties: properties
-        }
-      end
-    end
-
-    # given rules are the output of `parse_rules_properties`, it returns a similar object but for each rule, instead `selector` string have
-    # a parsed selector object: `Array<Array<{name: string, operator: nil|'>'|' '}>>`
-    def parse_rules_selectors(rules)
-      rules.map do |rule|
-        selectors = rule[:selector].split(',').map(&:strip)
-        selectors = selectors.map do |s|
-          parse_selector s
-        end
-        {
-          selectors: selectors,
-          properies: rule[:properties]
-        }
-      end
-    end
-
-    # independent method to parse string selectors like 'a>b c' to `Array<{name: string, operator: nil|'>'|' '}>`
-    def parse_selector(s)
-      a = s.split(/([\s>])/)
-      i = 0
-      results = []
-      while i < a.length
-        results.push(name: a[i], operator: a[i + 1])
-        i += 2
-      end
-      results = results.reject { |result| result[:name].strip == '' }
-      results
-    end
-  end
-end
-
-CSSParser = TermGui::CSSParser
-
-# p = CSSParser.new
-# # p.parse('foo {bg: red; padding-top: 3} .bar .primary {border: double black}; .sidebar .container { padding: 1}')
-# s = 'a>  b c>d f'
-# p CSSParser.new.parse_selector 'a>  b c>d f'
-# a = s.split(/([\s>])/) # .select{|s|s.strip!=''}
-# p a
-# i = 0
-# results = []
-# while i < a.length
-#   results.push(name: a[i], operator: a[i + 1])
-#   i += 2
-# end
-# results = results.reject { |result| result[:name].strip == '' }
-# p results
-
-# parser = CSSParser.new
-# expected = '[{:selector=>"foo", :properties=>[{:name=>"bg", :value=>"red"}, {:name=>"padding-top", :value=>"3"}]}, {:selector=>".bar .primary", :properties=>[{:name=>"border", :value=>"double black"}]}, {:selector=>"; .sidebar .container", :properties=>[{:name=>"padding", :value=>"1"}]}]'
-# rules = parser.parse_rules_properties(parser.parse_rules('foo {bg: red; padding-top: 3} .bar .primary {border: double black}; .sidebar .container { padding: 1}'))
-# actual = parser.parse_rules_selectors(rules)
-# p actual

data/src/util/css_query.rb

@@ -1,23 +0,0 @@
-# will select descendants from given `root` Node that matches given string selector (like `a>.b c`).
-# The semantic mapping between ' ' and '>' "operators" and Node attributes can be overriden by subclassing
-module NodeSelector
-  # def initialize
-  #   @parser = CSSParser.new
-  # end
-  def css(root, selector)
-    @parser |= CSSParser.new
-    parsed = @parser.parse_selector(selector)
-    results = []
-    css_impl([root], parsed, results)
-  end
-
-  protected
-
-  # actual recursive css() implementation. each recursion will consume the first parsed passing the rest to the next call.
-  # roots will be also updated accordingly to current matches.
-  # The recursion condition is meet when parsed.length==1 (the last match step) which will return total matched elements
-  # flatten storing it on given imput result argument.
-  def css_impl(_roots, _parsed)
-    throw 'TODO'
-  end
-end

data/src/util/easing.rb

@@ -1,364 +0,0 @@
-# module TermGui
-#   module Easing
-#     def self.animate(
-#       duration: 1000,
-#       draw: nil, #  (n: number) => void
-#       timing: nil, # (n: number, c?: number, d?: number, x?: number, y?: number) => number
-#       lapse: 0.1
-#     )
-#     end
-#   end
-# end
-
-# # import { isObject } from 'misc-utils-of-mine-generic'
-
-# # type Timing = (n: number, c?: number, d?: number, x?: number, y?: number) => number
-# # type TimingObject = { fn: (duration: number) => Timing }
-# # export function animate({ duration, draw, timing, lapse }: {
-# #   duration: number
-# #   draw: (n: number) => void
-# #   timing: Timing | TimingObject
-# #   lapse?: number
-# # }) {
-# #   if (isObject(timing)) {
-# #     timing = (timing as any).fn(duration)
-# #   }
-# #   let start = Date.now()
-# #   let progress = 0
-# #   requestAnimationFrame(function anim(time) {
-# #     let timeFraction = (time - start) / duration
-# #     if (timeFraction > 1) timeFraction = 1
-# #     progress = (timing as Timing)(timeFraction, time - start, duration)
-# #     draw(progress)
-# #     if (timeFraction < 1) {
-# #       requestAnimationFrame(anim, lapse)
-# #     }
-# #   })
-# # }
-
-# # function requestAnimationFrame(f: (...args: any[]) => any, lapse = 0) {
-# #   setTimeout(() => f(Date.now()), lapse)
-# # }
-
-# # export namespace easing {
-# #   function makeEaseOut(timing: Timing) {
-# #     return function(timeFraction: any) {
-# #       return 1 - timing(1 - timeFraction)
-# #     }
-# #   }
-
-# #   function bounceFn(timeFraction: number) {
-# #     for (let a = 0, b = 1, result; 1; a += b, b /= 2) {
-# #       if (timeFraction >= (7 - 4 * a) / 11) {
-# #         return -Math.pow((11 - 6 * a - 11 * timeFraction) / 4, 2) + Math.pow(b, 2)
-# #       }
-# #     }
-# #   }
-
-# #   /** Imagine we are dropping a ball. It falls down, then bounces back a few times and stops. The bounce function does the same, but in the reverse order: “bouncing” starts immediately. */
-# #   export const bounceEasyOut: () => Timing = () => makeEaseOut(bounceFn as any)
-
-# #   /** parabolic curve */
-# #   export function quad(timeFraction: number) {
-# #     return Math.pow(timeFraction, 2)
-# #   }
-# #   // export const swing = t => 0.5 - Math.cos(t * Math.PI) / 2
-
-# #   /**
-# #    * “bow shooting”. First we “pull the bowstring”, and then “shoot”.
-# #    * @param x “elasticity coefficient”. The distance of “bowstring pulling” is defined by it. Default value 1.5.
-# #    */
-# #   export const back = (x = 1.5) => (timeFraction: number) => Math.pow(timeFraction, 2) * ((x + 1) * timeFraction - x)
-# #   /**
-# #    * @param x “initial range”
-# #    */
-# #   export const elastic = (x = 1.5) => (timeFraction: number) =>
-# #     Math.pow(2, 10 * (timeFraction - 1)) * Math.cos(((20 * Math.PI * x) / 3) * timeFraction)
-
-# #   function makeEaseInOut(timing: Timing) {
-# #     return function(timeFraction: number) {
-# #       if (timeFraction < 0.5) return timing(2 * timeFraction) / 2
-# #       else return (2 - timing(2 * (1 - timeFraction))) / 2
-# #     }
-# #   }
-
-# #   export const bounceEaseInOut: () => Timing = () => makeEaseInOut(bounceFn as any)
-
-# #   let c = 1,
-# #     b = 0
-# #   export const easeInQuad: () => Timing = () =>
-# #     ({ fn: (d: number) => (x: number, t: number) => c * (t /= d) * t + b } as any)
-
-# #   export const easeOutQuad: () => Timing = () =>
-# #     ({ fn: (d: number) => (x: number, t: number) => -c * (t /= d) * (t - 2) + b } as any)
-# #   export const easeInOutQuad: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         if ((t /= d / 2) < 1) return (c / 2) * t * t + b
-# #         return (-c / 2) * (--t * (t - 2) - 1) + b
-# #       }
-# #     } as any)
-# #   export const easeInElastic: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         let s = 1.70158
-# #         let p = 0
-# #         let a = c
-# #         if (t == 0) return b
-# #         if ((t /= d) == 1) return b + c
-# #         if (!p) p = d * 0.3
-# #         if (a < Math.abs(c)) {
-# #           a = c
-# #           let s = p / 4
-# #         } else {
-# #           s = (p / (2 * Math.PI)) * Math.asin(c / a)
-# #         }
-# #         return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin(((t * d - s) * (2 * Math.PI)) / p)) + b
-# #       }
-# #     } as any)
-
-# #   export const easeOutBounce: () => TimingObject = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         if ((t /= d) < 1 / 2.75) {
-# #           return c * (7.5625 * t * t) + b
-# #         } else if (t < 2 / 2.75) {
-# #           return c * (7.5625 * (t -= 1.5 / 2.75) * t + 0.75) + b
-# #         } else if (t < 2.5 / 2.75) {
-# #           return c * (7.5625 * (t -= 2.25 / 2.75) * t + 0.9375) + b
-# #         } else {
-# #           return c * (7.5625 * (t -= 2.625 / 2.75) * t + 0.984375) + b
-# #         }
-# #       }
-# #     } as any)
-
-# #   export const easeInCubic: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         return c * (t /= d) * t * t + b
-# #       }
-# #     } as any)
-
-# #   export const easeOutCubic: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         return c * ((t = t / d - 1) * t * t + 1) + b
-# #       }
-# #     } as any)
-
-# #   export const easeInOutCubic: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         if ((t /= d / 2) < 1) return (c / 2) * t * t * t + b
-# #         return (c / 2) * ((t -= 2) * t * t + 2) + b
-# #       }
-# #     } as any)
-
-# #   export const easeInQuart: Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         return c * (t /= d) * t * t * t + b
-# #       }
-# #     } as any)
-
-# #   export const easeInOutQuart: Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         if ((t /= d / 2) < 1) return (c / 2) * t * t * t * t + b
-# #         return (-c / 2) * ((t -= 2) * t * t * t - 2) + b
-# #       }
-# #     } as any)
-
-# #   export const easeInQuint: Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         return c * (t /= d) * t * t * t * t + b
-# #       }
-# #     } as any)
-
-# #   export const easeOutQuint: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         return c * ((t = t / d - 1) * t * t * t * t + 1) + b
-# #       }
-# #     } as any)
-
-# #   export const easeInExpo: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         return t == 0 ? b : c * Math.pow(2, 10 * (t / d - 1)) + b
-# #       }
-# #     } as any)
-
-# #   export const easeInOutQuint: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         if ((t /= d / 2) < 1) return (c / 2) * t * t * t * t * t + b
-# #         return (c / 2) * ((t -= 2) * t * t * t * t + 2) + b
-# #       }
-# #     } as any)
-
-# #   export const easeInSine: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         return -c * Math.cos((t / d) * (Math.PI / 2)) + c + b
-# #       }
-# #     } as any)
-# #   export const easeInOutElastic: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         let s = 1.70158
-# #         let p = 0
-# #         let a = c
-# #         if (t == 0) return b
-# #         if ((t /= d / 2) == 2) return b + c
-# #         if (!p) p = d * (0.3 * 1.5)
-# #         if (a < Math.abs(c)) {
-# #           a = c
-# #           let s = p / 4
-# #         } else {
-# #           s = (p / (2 * Math.PI)) * Math.asin(c / a)
-# #         }
-# #         if (t < 1) return -0.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin(((t * d - s) * (2 * Math.PI)) / p)) + b
-# #         return a * Math.pow(2, -10 * (t -= 1)) * Math.sin(((t * d - s) * (2 * Math.PI)) / p) * 0.5 + c + b
-# #       }
-# #     } as any)
-
-# #   export const easeOutElastic: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         let s = 1.70158
-# #         let p = 0
-# #         let a = c
-# #         if (t == 0) return b
-# #         if ((t /= d) == 1) return b + c
-# #         if (!p) p = d * 0.3
-# #         if (a < Math.abs(c)) {
-# #           a = c
-# #           let s = p / 4
-# #         } else {
-# #           s = (p / (2 * Math.PI)) * Math.asin(c / a)
-# #         }
-# #         return a * Math.pow(2, -10 * t) * Math.sin(((t * d - s) * (2 * Math.PI)) / p) + c + b
-# #       }
-# #     } as any)
-# #   export const easeInOutExpo: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         if (t == 0) return b
-# #         if (t == d) return b + c
-# #         if ((t /= d / 2) < 1) return (c / 2) * Math.pow(2, 10 * (t - 1)) + b
-# #         return (c / 2) * (-Math.pow(2, -10 * --t) + 2) + b
-# #       }
-# #     } as any)
-
-# #   export const easeInOutBack: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number) => {
-# #         let s = 1.70158
-# #         if ((t /= d / 2) < 1) return (c / 2) * (t * t * (((s *= 1.525) + 1) * t - s)) + b
-# #         return (c / 2) * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2) + b
-# #       }
-# #     } as any)
-
-# #   export const easeOutBack: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number, d: number) => {
-# #         let s = 1.70158
-# #         return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b
-# #       }
-# #     } as any)
-
-# #   export const easeInBounce: () => TimingObject = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number, d: number) => {
-# #         return c - easeOutBounce().fn(d)(x, d - t, 0, c, d) + b
-# #       }
-# #     } as any)
-
-# #   export const easeInOutBounce: () => Timing = () =>
-# #     ({
-# #       fn: (d: number) => (x: number, t: number, d: number) => {
-# #         if (t < d / 2) return easeInBounce().fn(d)(x, t * 2, 0, c, d) * 0.5 + b
-# #         return easeOutBounce().fn(d)(x, t * 2 - d, 0, c, d) * 0.5 + c * 0.5 + b
-# #       }
-# #     } as any)
-# # }
-
-# # // animate({
-# # //   duration: 2000,
-# # //   timing: easeInQuad(),
-# # //   lapse: 20,
-# # //   draw(progress) {
-# # //   console.log(progress * 100 + '%');
-# # //   }
-# # // });
-
-# # // TODO:
-# # // easeInOutSine: function (x, t, b, c, d) {
-# # //   return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
-# # // },
-# # // easeOutExpo: function (x, t, b, c, d) {
-# # //   return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
-# # // },
-# # // easeInCirc: function (x, t, b, c, d) {
-# # //   return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b;
-# # // },
-# # // easeOutCirc: function (x, t, b, c, d) {
-# # //   return c * Math.sqrt(1 - (t=t/d-1)*t) + b;
-# # // },
-# # // easeInOutCirc: function (x, t, b, c, d) {
-# # //   if ((t/=d/2) < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b;
-# # //   return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b;
-# # // },
-# # // easeInBack: function (x, t, b, c, d, s) {
-# # //   if (s == undefined) s = 1.70158;
-# # //   return c*(t/=d)*t*((s+1)*t - s) + b;
-# # // },
-# # // easeInBounce: function (x, t, b, c, d) {
-# # //   return c - jQuery.easing.easeOutBounce (x, d-t, 0, c, d) + b;
-# # // },
-# # // easeInOutBounce: function (x, t, b, c, d) {
-# # //   if (t < d/2) return jQuery.easing.easeInBounce (x, t*2, 0, c, d) * .5 + b;
-# # //   return jQuery.easing.easeOutBounce (x, t*2-d, 0, c, d) * .5 + c*.5 + b;
-# # // }
-
-# # // animate({
-# # //   duration: 1000,
-# # //   timing(timeFraction) {
-# # //     return timeFraction;
-# # //   },
-# # //   draw(progress) {
-# # //   console.log(progress * 100 + '%');
-
-# # //   }
-# # // });
-
-# # // setImmediate((t)=>{
-# # //   console.log(t);
-
-# # // })
-
-# # // function requestAnimationFrame(f){
-# # //   setImmediate(()=>f(Date.now()))
-# # // }
-
-# # // function animate({duration, draw, timing}) {
-
-# # //   let start = performance.now();
-
-# # //   requestAnimationFrame(function animate(time) {
-# # //     let timeFraction = (time - start) / duration;
-# # //     if (timeFraction > 1) timeFraction = 1;
-
-# # //     let progress = timing(timeFraction)
-
-# # //     draw(progress);
-
-# # //     if (timeFraction < 1) {
-# # //       requestAnimationFrame(animate);
-# # //     }
-
-# # //   });
-# # // }
-# # // The code for it: