update changelog

1.0.0

.github/workflows/kdocs.yml

@@ -0,0 +1,24 @@
+name: Publish KDocs
+on:
+  push:
+    branches:
+      - master
+jobs:
+  publishing:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-java@v1
+        with:
+          java-version: 11
+      - name: Fix android 32.0.0 dx
+        continue-on-error: true
+        run: cd /usr/local/lib/android/sdk/build-tools/32.0.0/ && cp d8 dx && cd lib  && cp d8.jar dx.jar
+      - name: Build
+        run: ./gradlew dokkaHtml
+      - name: Publish KDocs
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./build/dokka/html
+          publish_branch: kdocs

.github/workflows/publishing_packages.yml

@@ -1,4 +1,3 @@
-
 name: Publish package to GitHub Packages
 on: [push]
 jobs:
@@ -8,15 +7,21 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
-          java-version: 1.8
+          java-version: 11
       - name: Update version
         run: |
           branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"
           sed -i -e "s/^version=\([0-9\.]*\)/version=\1-branch_$branch-build${{ github.run_number }}/" gradle.properties
       - name: prebuild
         run: ./gradlew clean build
+      - name: Publish to Gitea
+        continue-on-error: true
+        run: ./gradlew publishAllPublicationsToGiteaRepository
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
       - name: Publish package
-        run: ./gradlew --no-parallel publishAllPublicationsToGithubPackagesRepository -x signJsPublication -x signJvmPublication -x signKotlinMultiplatformPublication -x signMetadataPublication -x signAndroidReleasePublication
+        continue-on-error: true
+        run: ./gradlew --no-parallel publishAllPublicationsToGithubPackagesRepository
         env:
           GITHUBPACKAGES_USER: ${{ github.actor }}
           GITHUBPACKAGES_PASSWORD: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -9,4 +9,6 @@ settings.xml
 build/
 out/
 
+kotlin-js-store/
+
 local.properties

CHANGELOG.md

@@ -1,5 +1,148 @@
 # Changelog
 
+## 2.0.0
+
+* Versions
+  * `Kotlin`: `1.8.21`
+  * `Klock`: `4.0.1`
+* Support of `mingwx64` platform
+
+## 1.0.0
+
+* Versions
+  * `Kotlin`: `1.8.20`
+  * `AndroidXWork`: `2.8.1`
+
+## 0.10.0
+
+* New extensions for `KronScheduler`:
+  * `asTzFlowWithoutDelays`/`asFlowWithoutDelays`
+  * `asTzFlowWithDelays`/`asFlowWithDelays`
+* Old `KronScheduler.asFlow` and `KronScheduler.asTzFlow` temporarily marked as deprecated: after several versions their
+behaviour will be changed to undelayed one
+* All the flow extensions now use `cold` non-channel flows. Potentially it should increase performance and decrease memory usage
+
+## 0.9.0
+
+* Versions
+  * `Kotlin`: `1.8.10`
+  * `AndroidXWork`: `2.8.0`
+
+## 0.8.5
+
+* Project is now available in owner `Gitea`: https://git.inmo.dev/InsanusMokrassar/-/packages/maven/dev.inmo-krontab
+* `KronSchedulerTz#next` with incoming `DateTime` now will use adjusted local time instead of unadjusted one
+* `CronDateTimeSchedulerTz#next` with incoming `DateTime` will convert that parameter to internal offset directly
+
+## 0.8.4
+
+* Versions
+  * `Kotlin`: `1.7.22`
+
+## 0.8.3
+
+* Versions
+  * `Kotlin`: `1.7.21`
+  * `Klock`: `3.4.0`
+
+## 0.8.2
+
+**THIS VERSION HAS CHANGED COMPILE ANDROID SDK FROM 32 -> 33**
+
+* Versions
+  * `Kotlin`: `1.7.20`
+  * `Klock`: `3.2.0`
+
+## 0.8.1
+
+* Versions
+  * `Klock`: `3.1.0`
+
+## 0.8.0
+
+**THIS VERSION HAS CHANGED MIN ANDROID SDK FROM 19 -> 21**
+
+* Versions
+  * `Kotlin`: `1.7.10`
+  * `Klock`: `3.0.0`
+
+## 0.7.5
+
+* Versions
+  * `Coroutines`: `1.6.4`
+
+## 0.7.4
+
+* Versions
+  * `Coroutines`: `1.6.3`
+
+## 0.7.3
+
+* Versions
+  * `Kotlin`: `1.6.21`
+* Several bug fixes ([#27](https://github.com/InsanusMokrassar/krontab/issues/27), [#34](https://github.com/InsanusMokrassar/krontab/issues/34))
+* New factories for `KronScheduler` and `KronSchedulerTz` (fix of [#35](https://github.com/InsanusMokrassar/krontab/issues/35))
+* Fill extensions for flow with time zones (fix of [#33](https://github.com/InsanusMokrassar/krontab/issues/33))
+
+## 0.7.2
+
+* Versions
+  * `Coroutines`: `1.6.1`
+  * `Klock`: `2.7.0`
+* Deprecate `do*Local` due to their redundancy (use `do*` instead)
+* Add support of milliseconds as optional parameter after month (fix of [#31](https://github.com/InsanusMokrassar/krontab/issues/31))
+* Add support of filters for `Flow`s with `DateTime` (fix of [#30](https://github.com/InsanusMokrassar/krontab/issues/30))
+
+## 0.7.1
+
+* Versions
+  * `Klock`: `2.5.2`
+
+## 0.7.0
+
+**ALL DEPRECATIONS HAVE BEEN REMOVED**
+
+* Versions
+  * `Kotlin`: `1.6.10`
+  * `Klock`: `2.4.10`
+  * `Coroutines`: `1.6.0`
+  * `Androidx Work`: `2.7.1`
+
+## 0.6.6
+
+* Versions
+  * `Klock`: `2.4.8`
+  * `Androidx Work`: `2.7.0`
+
+## 0.6.5
+
+* Flows now use `doWhile` functions
+* `doWhile` now use additional delay (for 1 ms) for cases when `block` executing too fast
+* New extensions for `KronScheduler`: `do(Once/While/Infinity)Local`/`do(Once/While/Infinity)Tz`
+
+## 0.6.4
+
+* Versions
+  * `Kotlin`: `1.5.31`
+  * `Coroutines`: `1.5.2`
+  * `Klock`: `2.4.2`
+  * `Androidx Work`: `2.6.0`
+
+## 0.6.3
+
+* Versions
+  * `Kotlin`: `1.5.30`
+  * `Klock`: `2.4.0`
+
+## 0.6.2
+
+**LEGACY COMPILER VARIANT FOR JS IS NOT AVAILABLE SINCE THIS UPDATE**
+
+* Versions
+  * `Kotlin`: `1.5.21`
+  * `Coroutines`: `1.5.1`
+  * `Klock`: `2.3.1`
+
 ## 0.6.1
 
 * Versions

README.md

@@ -1,22 +1,20 @@
 # krontab
 
- [![Download](https://api.bintray.com/packages/insanusmokrassar/InsanusMokrassar/krontab-mpp/images/download.svg) ](https://bintray.com/insanusmokrassar/InsanusMokrassar/krontab-mpp/_latestVersion)
- [![Maven Central](https://maven-badges.herokuapp.com/maven-central/dev.inmo/krontab/badge.svg)](https://maven-badges.herokuapp.com/maven-central/dev.inmo/krontab)
- [![Build Status](https://travis-ci.com/InsanusMokrassar/krontab.svg?branch=master)](https://travis-ci.com/InsanusMokrassar/krontab)
- 
+[![Maven Central](https://maven-badges.herokuapp.com/maven-central/dev.inmo/krontab/badge.svg)](https://maven-badges.herokuapp.com/maven-central/dev.inmo/krontab)
+
+[![Telegram Chat](https://img.shields.io/badge/Telegram%20Chat-0288D1?style=for-the-badge&logo=telegram&logoColor=white)](https://inmodev_chat.t.me)
+
+![JVM](https://img.shields.io/badge/JVM-red?style=for-the-badge&logo=openjdk&logoColor=white)
+![Android](https://img.shields.io/badge/Android-green?style=for-the-badge&logo=android&logoColor=white)
+![Js](https://img.shields.io/badge/JavaScript-323330?style=for-the-badge&logo=javascript&logoColor=F7DF1E)
+![Linux x64](https://img.shields.io/badge/Linux%20x64-white?style=for-the-badge&logo=linux&logoColor=black)
+
+[![KDocs](https://img.shields.io/badge/KDocs-323330?style=for-the-badge&logo=Kotlin&logoColor=7F52FF)](https://insanusmokrassar.github.io/krontab/)
+[![Tutorials](https://img.shields.io/badge/Tutorials-0288D1?style=for-the-badge&logo=bookstack&logoColor=white)](https://bookstack.inmo.dev/books/krontab)
+
 Library was created to give oppotunity to launch some things from time to time according to some schedule in
 runtime of applications.
 
-| Table of content |
-|---|
-| [ How to use ](#how-to-use) |
-| [ How to use: Including in project ](#including-in-project) |
-| [ How to use: Config from string ](#config-from-string) |
-| [ How to use: Config via builder (DSL preview) ](#config-via-builder) |
-| [ How to use: KronScheduler as a Flow ](#KronScheduler-as-a-Flow) |
-| [ How to use: Offsets ](#Offsets) |
-| [ How to use: Note about week days ](#Note-about-week-days) |
-
 ## How to use
 
 There are several ways to configure and use this library:
@@ -29,7 +27,7 @@ Anyway, to start some action from time to time you will need to use one of exten
 ```kotlin
 val kronScheduler = /* creating of KronScheduler instance */;
 
-kronScheuler.doWhile {
+kronScheduler.doWhile {
     // some action
     true // true - repeat on next time
 }
@@ -46,7 +44,7 @@ implementation "dev.inmo:krontab:$krontab_version"
 
 Next version is the latest currently for the library:
 
-[ ![Download](https://api.bintray.com/packages/insanusmokrassar/InsanusMokrassar/krontab-mpp/images/download.svg) ](https://bintray.com/insanusmokrassar/InsanusMokrassar/krontab-mpp/_latestVersion)
+[![Maven Central](https://maven-badges.herokuapp.com/maven-central/dev.inmo/krontab/badge.svg)](https://maven-badges.herokuapp.com/maven-central/dev.inmo/krontab)
 
 For old version of Gradle, instead of `implementation` word developers must use `compile`.
 
@@ -133,6 +131,38 @@ kronScheduler.doInfinity {
 
 All of these examples will do the same things: print `Called` message every five seconds.
 
+### do\* functions
+
+With regular `doOnce`/`doWhile`/`doInfinity` there are two types of their variations: **local** and **timezoned**. Local
+variations (`doOnceLocal`/`doWhileLocal`/`doInfinityLocal`) will pass `DateTime` as an argument into the block:
+
+```kotlin
+doInfinityLocal("/5 * * * *") {
+    println(it) // will print current date time
+}
+```
+
+Timezoned variations (`doOnceTz`/`doWhileTz`/`doInfinityTz`) will do the same thing but pass as an argument `DateTimeTz`:
+
+```kotlin
+doInfinityTz("/5 * * * * 0o") {
+    println(it) // will print current date time in UTC
+}
+```
+
+It is useful in cases when you need to get the time of calling and avoid extra calls to system time.
+
+#### Helpful table for 
+
+|  | No args | Local `DateTime` | Local `DateTimeTz` with offset of `KronScheduler` |
+|---| ------- | ---------------- | ------------------------------------------------- |
+| **Call only near time** | doOnce | doOnceLocal | doOnceTz |
+| **Call while condition is true** | doWhile | doWhileLocal | doWhileTz |
+| **Work infinity*** | doInfinity | doInfinityLocal | doInfinityTz |
+
+*Here there is an important notice, that `Work infinity` is not exactly `infinity`. Actually, that means that `do while
+coroutine is alive` and in fact executing will be stopped when coroutine became cancelled.
+
 ### KronScheduler as a Flow
 
 Any `KronScheduler`can e converted to a `Flow<DateTime` using extension `asFlow`:
@@ -163,7 +193,7 @@ flow.takeWhile {
 Offsets in this library works via passing parameter ending with `o` in any place after `month` config. Currently
 there is only one format supported for offsets: minutes of offsets. To use time zones you will need to call `next`
 method with `DateTimeTz` argument or `nextTimeZoned` method with any `KronScheduler` instance, but in case if this
-scheduler is not instance of `KronSchedulerTz` it will works like you passed just `DateTime`.
+scheduler is not instance of `KronSchedulerTz` it will work like you passed just `DateTime`.
 
 Besides, in case you wish to use time zones explicitly, you will need to get `KronSchedulerTz`. It is possible by:
 

build.gradle

@@ -1,7 +1,7 @@
 buildscript {
     repositories {
         mavenLocal()
-        jcenter()
+        // jcenter()
         mavenCentral()
         google()
     }
@@ -10,7 +10,7 @@ buildscript {
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         classpath "com.github.breadmoirai:github-release:$github_release_plugin_version"
         classpath "com.getkeepsafe.dexcount:dexcount-gradle-plugin:$dexcount_version"
-        classpath 'com.android.tools.build:gradle:4.1.3'
+        classpath "com.android.tools.build:gradle:$android_gradle_version"
     }
 }
 
@@ -40,9 +40,9 @@ apply from: "github_release.gradle"
 
 repositories {
     mavenLocal()
-    jcenter()
+    // jcenter()
     mavenCentral()
-    maven { url "https://kotlin.bintray.com/kotlinx" }
+    // maven { url "https://kotlin.bintray.com/kotlinx" }
     google()
 }
 
@@ -50,13 +50,15 @@ apply from: './dokka.gradle'
 
 kotlin {
     jvm()
-    js(BOTH) {
+    js(IR) {
         browser()
         nodejs()
     }
     android {
         publishAllLibraryVariants()
     }
+    linuxX64()
+    mingwX64()
 
 
     sourceSets {
@@ -79,6 +81,7 @@ kotlin {
             dependencies {
                 implementation kotlin('test-common')
                 implementation kotlin('test-annotations-common')
+                implementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:$kotlin_coroutines_version"
             }
         }
         jvmTest {
@@ -102,8 +105,9 @@ kotlin {
 apply plugin: 'com.getkeepsafe.dexcount'
 
 android {
-    compileSdkVersion "$android_compileSdkVersion".toInteger()
+    compileSdk "$android_compileSdkVersion".toInteger()
     buildToolsVersion "$android_buildToolsVersion"
+    namespace "${group}.${project.name}"
 
     defaultConfig {
         minSdkVersion "$android_minSdkVersion".toInteger()
@@ -132,3 +136,8 @@ android {
         }
     }
 }
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

dokka.gradle

@@ -15,31 +15,40 @@ dokkaHtml {
     }
 
     moduleName.set("kdocs")
-
+    
     dokkaSourceSets {
-        configureEach {
-            skipDeprecated.set(true)
-            includeNonPublic.set(true)
-            reportUndocumented.set(true)
+        switch (true) {
+            case project.hasProperty("DOKKA_PATH"):
+                outputDirectory = new File(project.property("DOKKA_PATH").toString())
+                break
+            case System.getenv("DOKKA_PATH") != null:
+                outputDirectory = new File(System.getenv("DOKKA_PATH"))
+                break
+        }
 
-            sourceLink {
-                localDirectory.set(file("./"))
-                remoteUrl.set(new URL("https://github.com/InsanusMokrassar/krontab/blob/master/"))
-                remoteLineSuffix.set("#L")
+        dokkaSourceSets {
+            configureEach {
+                skipDeprecated.set(true)
+
+                sourceLink {
+                    localDirectory.set(file("./"))
+                    remoteUrl.set(new URL("https://github.com/InsanusMokrassar/krontab/blob/master/"))
+                    remoteLineSuffix.set("#L")
+                }
             }
-        }
 
-        named("commonMain") {
-            sourceRoot { path = "src/commonMain" }
-        }
+            named("commonMain") {
+                sourceRoots.setFrom(findSourcesWithName("commonMain"))
+            }
 
 //
-//        named("jsMain") {
-//            sourceRoot { path = "src/jsMain" }
-//        }
+//            named("jsMain") {
+//                sourceRoot { path = "src/jsMain" }
+//            }
 //
-//        named("jvmMain") {
-//            sourceRoot { path = "src/jvmMain" }
-//        }
+//            named("jvmMain") {
+//                sourceRoot { path = "src/jvmMain" }
+//            }
+        }
     }
 }

github_release.gradle

@@ -21,7 +21,7 @@ if (new File(projectDir, "secret.gradle").exists()) {
         owner "InsanusMokrassar"
         repo "${rootProject.name}"
 
-        tagName "${project.version}"
+        tagName "v${project.version}"
         releaseName "${project.version}"
         targetCommitish "${project.version}"
 

gradle.properties

@@ -1,3 +1,4 @@
+org.gradle.jvmargs=-Xmx512m
 kotlin.code.style=official
 org.gradle.parallel=true
 kotlin.js.generate.externals=true
@@ -8,31 +9,31 @@ android.useAndroidX=true
 android.enableJetifier=false
 
 
-kotlin_version=1.5.10
-kotlin_coroutines_version=1.5.0
+kotlin_version=1.8.21
+kotlin_coroutines_version=1.6.4
 
-dokka_version=1.4.32
+dokka_version=1.8.10
 
-klockVersion=2.1.2
+klockVersion=4.0.1
 
 ## Github reease
 
-github_release_plugin_version=2.2.12
+github_release_plugin_version=2.4.1
 
 ## Android
 
-android_minSdkVersion=19
-android_compileSdkVersion=30
-android_buildToolsVersion=30.0.3
-dexcount_version=2.0.0
+android_gradle_version=7.4.2
+android_minSdkVersion=21
+android_compileSdkVersion=33
+android_buildToolsVersion=33.0.2
+dexcount_version=4.0.0
 junit_version=4.12
-test_ext_junit_version=1.1.2
-espresso_core=3.3.0
+test_ext_junit_version=1.1.3
+espresso_core=3.4.0
 
-androidx_work_version=2.5.0
+androidx_work_version=2.8.1
 
 ## Common
 
-version=0.6.1
-android_code_version=5
-
+version=2.0.0
+android_code_version=26

gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.1-bin.zip

mpp_config.kpsb

@@ -1 +1 @@
-{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/krontab/blob/master/LICENSE"}],"mavenConfig":{"name":"Krontab","description":"It is an analog of crontab util for Kotlin Coroutines","url":"https://github.com/InsanusMokrassar/krontab","vcsUrl":"https://github.com/InsanusMokrassar/krontab.git","includeGpgSigning":true,"developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/krontab"},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}]}}
+{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/krontab/blob/master/LICENSE"}],"mavenConfig":{"name":"Krontab","description":"It is an analog of crontab util for Kotlin Coroutines","url":"https://github.com/InsanusMokrassar/krontab","vcsUrl":"https://github.com/InsanusMokrassar/krontab.git","developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/krontab"},{"name":"Gitea","url":"https://git.inmo.dev/api/packages/InsanusMokrassar/maven","credsType":{"type":"dev.inmo.kmppscriptbuilder.core.models.MavenPublishingRepository.CredentialsType.HttpHeaderCredentials","headerName":"Authorization","headerValueProperty":"GITEA_TOKEN"}},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}}}

publish.gradle

@@ -1,5 +1,4 @@
 apply plugin: 'maven-publish'
-apply plugin: 'signing'
 
 task javadocsJar(type: Jar) {
     classifier = 'javadoc'
@@ -43,27 +42,58 @@ publishing {
                 maven {
                     name = "GithubPackages"
                     url = uri("https://maven.pkg.github.com/InsanusMokrassar/krontab")
+            
                     credentials {
                         username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
                         password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
                     }
+            
+                }
+            }
+            if (project.hasProperty('GITEA_TOKEN') || System.getenv('GITEA_TOKEN') != null) {
+                maven {
+                    name = "Gitea"
+                    url = uri("https://git.inmo.dev/api/packages/InsanusMokrassar/maven")
+            
+                    credentials(HttpHeaderCredentials) {
+                        name = "Authorization"
+                        value = project.hasProperty('GITEA_TOKEN') ? project.property('GITEA_TOKEN') : System.getenv('GITEA_TOKEN')
+                    }
+            
+                    authentication {
+                        header(HttpHeaderAuthentication)
+                    }
+            
                 }
             }
             if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
                 maven {
                     name = "sonatype"
                     url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
+            
                     credentials {
                         username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
                         password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
                     }
+            
                 }
             }
         }
     }
 }
-
-signing {
-    useGpgCmd()
-    sign publishing.publications
+    
+if (project.hasProperty("signing.gnupg.keyName")) {
+    apply plugin: 'signing'
+    
+    signing {
+        useGpgCmd()
+    
+        sign publishing.publications
+    }
+    
+    task signAll {
+        tasks.withType(Sign).forEach {
+            dependsOn(it)
+        }
+    }
 }

renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:base"
+  ]
+}

src/commonMain/kotlin/dev/inmo/krontab/Executes.kt

@@ -1,7 +1,11 @@
 package dev.inmo.krontab
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
+import korlibs.time.DateTimeTz
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlin.coroutines.coroutineContext
+
 
 /**
  * Execute [block] once at the [KronScheduler.next] time and return result of [block] calculation.
@@ -10,11 +14,37 @@ import kotlinx.coroutines.delay
  *
  * WARNING!!! In case if [KronScheduler.next] of [this] instance will return null, [block] will be called immediately
  */
-suspend inline fun <T> KronScheduler.doOnce(noinline block: suspend () -> T): T {
-    next() ?.let {
+suspend inline fun <T> KronScheduler.doOnce(noinline block: suspend (DateTime) -> T): T {
+    val time = nextOrNow().also {
         delay((it - DateTime.now()).millisecondsLong)
     }
-    return block()
+    return block(time)
+}
+
+/**
+ * Execute [block] once at the [KronScheduler.next] time and return result of [block] calculation.
+ *
+ * WARNING!!! If you want to launch it in parallel, you must do this explicitly.
+ *
+ * WARNING!!! In case if [KronScheduler.next] of [this] instance will return null, [block] will be called immediately
+ */
+@Deprecated("Replaceable", ReplaceWith("doOnce", "dev.inmo.krontab.doOnce"))
+suspend inline fun <T> KronScheduler.doOnceLocal(noinline block: suspend (DateTime) -> T): T = doOnce(block)
+
+/**
+ * Execute [block] once at the [KronScheduler.next] time and return result of [block] calculation.
+ *
+ * WARNING!!! If you want to launch it in parallel, you must do this explicitly.
+ *
+ * WARNING!!! In case if [KronScheduler.next] of [this] instance will return null, [block] will be called immediatelly
+ */
+suspend inline fun <T> KronScheduler.doOnceTz(noinline block: suspend (DateTimeTz) -> T): T {
+    val time = when (this) {
+        is KronSchedulerTz -> nextOrNowWithOffset()
+        else -> nextOrNow().local
+    }
+    delay((time - DateTimeTz.nowLocal()).millisecondsLong)
+    return block(time)
 }
 
 /**
@@ -23,14 +53,40 @@ suspend inline fun <T> KronScheduler.doOnce(noinline block: suspend () -> T): T
  */
 suspend inline fun <T> doOnce(
     scheduleConfig: String,
-    noinline block: suspend () -> T
+    noinline block: suspend (DateTime) -> T
 ) = buildSchedule(scheduleConfig).doOnce(block)
 
+/**
+ * Will [buildSchedule] using [scheduleConfig] and call [doOnce] on it
+ * @see buildSchedule
+ */
+suspend inline fun <T> doOnceTz(
+    scheduleConfig: String,
+    noinline block: suspend (DateTimeTz) -> T
+) = buildSchedule(scheduleConfig).doOnceTz(block)
+
+
 /**
  * Will execute [block] while it will return true as a result of its calculation
  */
-suspend inline fun KronScheduler.doWhile(noinline block: suspend () -> Boolean) {
-    do { val doNext = doOnce(block) } while (doNext)
+suspend inline fun KronScheduler.doWhile(noinline block: suspend (DateTime) -> Boolean) {
+    do {
+        delay(1L)
+    } while (doOnce(block))
+}
+/**
+ * Will execute [block] while it will return true as a result of its calculation
+ */
+@Deprecated("Replaceable", ReplaceWith("doWhile", "dev.inmo.krontab.doWhile"))
+suspend inline fun KronScheduler.doWhileLocal(noinline block: suspend (DateTime) -> Boolean) = doWhile(block)
+
+/**
+ * Will execute [block] while it will return true as a result of its calculation
+ */
+suspend inline fun KronScheduler.doWhileTz(noinline block: suspend (DateTimeTz) -> Boolean) {
+    do {
+        delay(1L)
+    } while (doOnceTz(block))
 }
 
 /**
@@ -40,16 +96,52 @@ suspend inline fun KronScheduler.doWhile(noinline block: suspend () -> Boolean)
  */
 suspend inline fun doWhile(
     scheduleConfig: String,
-    noinline block: suspend () -> Boolean
+    noinline block: suspend (DateTime) -> Boolean
 ) = buildSchedule(scheduleConfig).doWhile(block)
 
+/**
+ * Will [buildSchedule] using [scheduleConfig] and call [doWhile] with [block]
+ *
+ * @see buildSchedule
+ */
+@Deprecated("Replaceable", ReplaceWith("doWhile", "dev.inmo.krontab.doWhile"))
+suspend inline fun doWhileLocal(
+    scheduleConfig: String,
+    noinline block: suspend (DateTime) -> Boolean
+) = doWhile(scheduleConfig, block)
+
+/**
+ * Will [buildSchedule] using [scheduleConfig] and call [doWhile] with [block]
+ *
+ * @see buildSchedule
+ */
+suspend inline fun doWhileTz(
+    scheduleConfig: String,
+    noinline block: suspend (DateTimeTz) -> Boolean
+) = buildSchedule(scheduleConfig).doWhileTz(block)
+
+
 /**
  * Will execute [block] without any checking of result
  */
-suspend inline fun KronScheduler.doInfinity(noinline block: suspend () -> Unit) = doWhile {
-    block()
-    true
+suspend inline fun KronScheduler.doInfinity(noinline block: suspend (DateTime) -> Unit) = doWhile {
+    block(it)
+    coroutineContext.isActive
 }
+/**
+ * Will execute [block] without any checking of result
+ */
+@Deprecated("Replaceable", ReplaceWith("doInfinity", "dev.inmo.krontab.doInfinity"))
+suspend inline fun KronScheduler.doInfinityLocal(noinline block: suspend (DateTime) -> Unit) = doInfinity(block)
+
+/**
+ * Will execute [block] without any checking of result
+ */
+suspend inline fun KronScheduler.doInfinityTz(noinline block: suspend (DateTimeTz) -> Unit) = doWhileTz {
+    block(it)
+    coroutineContext.isActive
+}
+
 /**
  * Will [buildSchedule] using [scheduleConfig] and call [doInfinity] with [block]
  *
@@ -57,5 +149,26 @@ suspend inline fun KronScheduler.doInfinity(noinline block: suspend () -> Unit)
  */
 suspend inline fun doInfinity(
     scheduleConfig: String,
-    noinline block: suspend () -> Unit
+    noinline block: suspend (DateTime) -> Unit
 ) = buildSchedule(scheduleConfig).doInfinity(block)
+
+/**
+ * Will [buildSchedule] using [scheduleConfig] and call [doInfinity] with [block]
+ *
+ * @see buildSchedule
+ */
+@Deprecated("Replaceable", ReplaceWith("doInfinity", "dev.inmo.krontab.doInfinity"))
+suspend inline fun doInfinityLocal(
+    scheduleConfig: String,
+    noinline block: suspend (DateTime) -> Unit
+) = doInfinity(scheduleConfig, block)
+
+/**
+ * Will [buildSchedule] using [scheduleConfig] and call [doInfinity] with [block]
+ *
+ * @see buildSchedule
+ */
+suspend inline fun doInfinityTz(
+    scheduleConfig: String,
+    noinline block: suspend (DateTimeTz) -> Unit
+) = buildSchedule(scheduleConfig).doInfinityTz(block)

src/commonMain/kotlin/dev/inmo/krontab/KronScheduler.kt

@@ -1,6 +1,6 @@
 package dev.inmo.krontab
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 
 /**
  * This interface was created for abstraction of [next] operation. Currently, there is only

src/commonMain/kotlin/dev/inmo/krontab/KronSchedulerTz.kt

@@ -1,7 +1,7 @@
 package dev.inmo.krontab
 
-import com.soywiz.klock.DateTime
-import com.soywiz.klock.DateTimeTz
+import korlibs.time.DateTime
+import korlibs.time.DateTimeTz
 
 /**
  * This interface extending [KronScheduler] to use [DateTimeTz] with taking into account offset of incoming time for
@@ -13,7 +13,7 @@ import com.soywiz.klock.DateTimeTz
 interface KronSchedulerTz : KronScheduler {
     suspend fun next(relatively: DateTimeTz): DateTimeTz?
 
-    override suspend fun next(relatively: DateTime): DateTime? = next(relatively.localUnadjusted) ?.local
+    override suspend fun next(relatively: DateTime): DateTime? = next(relatively.local) ?.local
 }
 
 suspend fun KronSchedulerTz.nextOrRelative(relatively: DateTimeTz): DateTimeTz = next(relatively) ?: getAnyNext(
@@ -31,4 +31,4 @@ suspend fun KronScheduler.next(relatively: DateTimeTz) = if (this is KronSchedul
     this.next(relatively.local) ?.toOffsetUnadjusted(relatively.offset)
 }
 
-suspend fun KronScheduler.nextTimeZoned() = next(DateTime.now().local)
+suspend fun KronScheduler.nextTimeZoned() = next(DateTime.now().local)

src/commonMain/kotlin/dev/inmo/krontab/LambdaKronScheduler.kt

@@ -0,0 +1,13 @@
+package dev.inmo.krontab
+
+import korlibs.time.DateTime
+
+class LambdaKronScheduler(
+    private val onNext: suspend (DateTime) -> DateTime?
+) : KronScheduler {
+    override suspend fun next(relatively: DateTime): DateTime? = onNext(relatively)
+}
+
+fun KronScheduler(
+    onNext: suspend (DateTime) -> DateTime?
+) = LambdaKronScheduler(onNext)

src/commonMain/kotlin/dev/inmo/krontab/LambdaKronSchedulerTz.kt

@@ -0,0 +1,13 @@
+package dev.inmo.krontab
+
+import korlibs.time.DateTimeTz
+
+class LambdaKronSchedulerTz(
+    private val onNext: suspend (DateTimeTz) -> DateTimeTz?
+) : KronSchedulerTz {
+    override suspend fun next(relatively: DateTimeTz): DateTimeTz? = onNext(relatively)
+}
+
+fun KronSchedulerTz(
+    onNext: suspend (DateTimeTz) -> DateTimeTz?
+) = LambdaKronSchedulerTz(onNext)

src/commonMain/kotlin/dev/inmo/krontab/SchedulerShortcuts.kt

@@ -1,6 +1,6 @@
 package dev.inmo.krontab
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.krontab.builder.buildSchedule
 import dev.inmo.krontab.internal.*
 
@@ -16,6 +16,13 @@ val AnyTimeScheduler: KronScheduler by lazy {
     CronDateTimeScheduler(anyCronDateTime)
 }
 
+/**
+ * [KronScheduler.next] will always return [com.soywiz.klock.DateTime.now] + one millisecond
+ */
+val EveryMillisecondScheduler: KronScheduler by lazy {
+    buildSchedule { milliseconds { 0 every 1 } }
+}
+
 /**
  * [KronScheduler.next] will always return [com.soywiz.klock.DateTime.now] + one second
  */

src/commonMain/kotlin/dev/inmo/krontab/StringParser.kt

@@ -1,7 +1,7 @@
 package dev.inmo.krontab
 
-import com.soywiz.klock.TimezoneOffset
-import com.soywiz.klock.minutes
+import korlibs.time.TimezoneOffset
+import korlibs.time.minutes
 import dev.inmo.krontab.internal.*
 import dev.inmo.krontab.utils.Minutes
 
@@ -14,14 +14,15 @@ typealias KrontabTemplate = String
 /**
  * Parse [incoming] string and adapt according to next format: "* * * * *" where order of things:
  *
- * * seconds
- * * minutes
- * * hours
- * * dayOfMonth
- * * month
- * * (optional) year
- * * (optional) (can be placed anywhere after month) (must be marked with `o` at the end, for example: 60o == +01:00) offset
- * * (optional) (can be placed anywhere after month) dayOfWeek
+ * * **seconds**
+ * * **minutes**
+ * * **hours**
+ * * **dayOfMonth**
+ * * **month**
+ * * **year** (optional)
+ * * **offset** (optional) (can be placed anywhere after month) (must be marked with `o` at the end, for example: 60o == +01:00)
+ * * **dayOfWeek** (optional) (can be placed anywhere after month)
+ * * **milliseconds** (optional) (can be placed anywhere after month) (must be marked with `ms` at the end, for example: 500ms; 100-200ms)
  *
  * And each one (except of offsets) have next format:
  *
@@ -48,18 +49,21 @@ typealias KrontabTemplate = String
  * * Months ranges can be found in [monthRange]
  * * Years ranges can be found in [yearRange] (in fact - any [Int])
  * * WeekDay (timezone) ranges can be found in [dayOfWeekRange]
+ * * Milliseconds ranges can be found in [millisecondsRange]
  *
  * Examples:
  *
  * * "0/5 * * * *" for every five seconds triggering
  * * "0/5,L * * * *" for every five seconds triggering and on 59 second
  * * "0/15 30 * * *" for every 15th seconds in a half of each hour
- * * "1 2 3 F,4,L 5" for triggering in near first second of second minute of third hour of fourth day of may
- * * "1 2 3 F,4,L 5 60o" for triggering in near first second of second minute of third hour of fourth day of may with timezone UTC+01:00
- * * "1 2 3 F,4,L 5 60o 0-2w" for triggering in near first second of second minute of third hour of fourth day of may in case if it will be in Sunday-Tuesday week days with timezone UTC+01:00
- * * "1 2 3 F,4,L 5 2021" for triggering in near first second of second minute of third hour of fourth day of may of 2021st year
- * * "1 2 3 F,4,L 5 2021 60o" for triggering in near first second of second minute of third hour of fourth day of may of 2021st year with timezone UTC+01:00
- * * "1 2 3 F,4,L 5 2021 60o 0-2w" for triggering in near first second of second minute of third hour of fourth day of may of 2021st year if it will be in Sunday-Tuesday week days with timezone UTC+01:00
+ * * "0/15 30 * * * 500ms" for every 15th seconds in a half of each hour when milliseconds equal to 500
+ * * "1 2 3 F,4,L 5" for triggering in near first second of second minute of third hour of first, fifth and last days of may
+ * * "1 2 3 F,4,L 5 60o" for triggering in near first second of second minute of third hour of first, fifth and last days of may with timezone UTC+01:00
+ * * "1 2 3 F,4,L 5 60o 0-2w" for triggering in near first second of second minute of third hour of first, fifth and last days of may in case if it will be in Sunday-Tuesday week days with timezone UTC+01:00
+ * * "1 2 3 F,4,L 5 2021" for triggering in near first second of second minute of third hour of first, fifth and last days of may of 2021st year
+ * * "1 2 3 F,4,L 5 2021 60o" for triggering in near first second of second minute of third hour of first, fifth and last days of may of 2021st year with timezone UTC+01:00
+ * * "1 2 3 F,4,L 5 2021 60o 0-2w" for triggering in near first second of second minute of third hour of first, fifth and last days of may of 2021st year if it will be in Sunday-Tuesday week days with timezone UTC+01:00
+ * * "1 2 3 F,4,L 5 2021 60o 0-2w 500ms" for triggering in near first second of second minute of third hour of first, fifth and last days of may of 2021st year if it will be in Sunday-Tuesday week days with timezone UTC+01:00 when milliseconds will be equal to 500
  *
  * @return In case when offset parameter is absent in [incoming] will be used [createSimpleScheduler] method and
  * returned [CronDateTimeScheduler]. In case when offset parameter there is in [incoming] [KrontabTemplate] will be used
@@ -73,18 +77,22 @@ fun createSimpleScheduler(
     var offsetParsed: Int? = null
     var dayOfWeekParsed: Array<Byte>? = null
     var yearParsed: Array<Int>? = null
+    var millisecondsParsed: Array<Short>? = null
     val (secondsSource, minutesSource, hoursSource, dayOfMonthSource, monthSource) = incoming.split(" ").also {
         listOfNotNull(
             it.getOrNull(5),
             it.getOrNull(6),
-            it.getOrNull(7)
+            it.getOrNull(7),
+            it.getOrNull(8)
         ).forEach {
             val offsetFromString = parseOffset(it)
             val dayOfWeekFromString = parseWeekDay(it)
+            val millisecondsFromString = parseMilliseconds(it)
             offsetParsed = offsetParsed ?: offsetFromString
             dayOfWeekParsed = dayOfWeekParsed ?: dayOfWeekFromString
+            millisecondsParsed = millisecondsParsed ?: millisecondsFromString
             when {
-                dayOfWeekFromString != null || offsetFromString != null -> return@forEach
+                dayOfWeekFromString != null || offsetFromString != null || millisecondsFromString != null -> return@forEach
                 yearParsed == null -> {
                     yearParsed = parseYears(it)
                 }
@@ -100,10 +108,25 @@ fun createSimpleScheduler(
 
     return offsetParsed ?.let { offset ->
         createKronSchedulerWithOffset(
-            secondsParsed, minutesParsed, hoursParsed, dayOfMonthParsed, monthParsed, yearParsed, dayOfWeekParsed, TimezoneOffset(offset.minutes)
+            secondsParsed,
+            minutesParsed,
+            hoursParsed,
+            dayOfMonthParsed,
+            monthParsed,
+            yearParsed,
+            dayOfWeekParsed,
+            TimezoneOffset(offset.minutes),
+            millisecondsParsed ?: millisecondsArrayDefault
         )
     } ?: createKronScheduler(
-        secondsParsed, minutesParsed, hoursParsed, dayOfMonthParsed, monthParsed, yearParsed, dayOfWeekParsed
+        secondsParsed,
+        minutesParsed,
+        hoursParsed,
+        dayOfMonthParsed,
+        monthParsed,
+        yearParsed,
+        dayOfWeekParsed,
+        millisecondsParsed ?: millisecondsArrayDefault
     )
 }
 

src/commonMain/kotlin/dev/inmo/krontab/builder/SchedulerBuilder.kt

@@ -1,9 +1,10 @@
 package dev.inmo.krontab.builder
 
-import com.soywiz.klock.TimezoneOffset
-import com.soywiz.klock.minutes
+import korlibs.time.TimezoneOffset
+import korlibs.time.minutes
 import dev.inmo.krontab.KronScheduler
 import dev.inmo.krontab.KronSchedulerTz
+import dev.inmo.krontab.internal.*
 import dev.inmo.krontab.internal.createKronScheduler
 import dev.inmo.krontab.internal.createKronSchedulerWithOffset
 import dev.inmo.krontab.utils.Minutes
@@ -45,7 +46,8 @@ class SchedulerBuilder(
     private var month: Array<Byte>? = null,
     private var year: Array<Int>? = null,
     private var dayOfWeek: Array<Byte>? = null,
-    private val offset: Minutes? = null
+    private val offset: Minutes? = null,
+    private var milliseconds: Array<Short>? = null
 ) {
     private fun <I, T : TimeBuilder<I>> callAndReturn(
         initial: Array<I>?,
@@ -63,6 +65,17 @@ class SchedulerBuilder(
         } ?: builderValue
     }
 
+    /**
+     * Starts an milliseconds block
+     */
+    fun milliseconds(block: MillisecondsBuilder.() -> Unit) {
+        milliseconds = callAndReturn(
+            milliseconds,
+            MillisecondsBuilder(),
+            block
+        ) ?.toTypedArray()
+    }
+
     /**
      * Starts an seconds block
      */
@@ -147,6 +160,16 @@ class SchedulerBuilder(
      * @see dev.inmo.krontab.internal.createKronScheduler
      */
     fun build(): KronScheduler = offset ?.let {
-        createKronSchedulerWithOffset(seconds, minutes, hours, dayOfMonth, month, year, dayOfWeek, TimezoneOffset(it.minutes))
-    } ?: createKronScheduler(seconds, minutes, hours, dayOfMonth, month, year, dayOfWeek)
+        createKronSchedulerWithOffset(
+            seconds,
+            minutes,
+            hours,
+            dayOfMonth,
+            month,
+            year,
+            dayOfWeek,
+            TimezoneOffset(it.minutes),
+            milliseconds ?: millisecondsArrayDefault
+        )
+    } ?: createKronScheduler(seconds, minutes, hours, dayOfMonth, month, year, dayOfWeek, milliseconds ?: millisecondsArrayDefault)
 }

src/commonMain/kotlin/dev/inmo/krontab/builder/TimeBuilder.kt

@@ -122,6 +122,7 @@ sealed class TimeBuilder<T : Number> (
     internal fun build() = result ?.map(converter)
 }
 
+class MillisecondsBuilder : TimeBuilder<Short>(millisecondsRange, intToShortConverter)
 class SecondsBuilder : TimeBuilder<Byte>(secondsRange, intToByteConverter)
 class MinutesBuilder : TimeBuilder<Byte>(minutesRange, intToByteConverter)
 class HoursBuilder : TimeBuilder<Byte>(hoursRange, intToByteConverter)

src/commonMain/kotlin/dev/inmo/krontab/collection/CollectionKronScheduler.kt

@@ -1,7 +1,7 @@
 package dev.inmo.krontab.collection
 
-import com.soywiz.klock.DateTime
-import com.soywiz.klock.DateTimeTz
+import korlibs.time.DateTime
+import korlibs.time.DateTimeTz
 import dev.inmo.krontab.*
 import dev.inmo.krontab.internal.*
 

src/commonMain/kotlin/dev/inmo/krontab/internal/CronDateTime.kt

@@ -1,14 +1,14 @@
 package dev.inmo.krontab.internal
 
-import com.soywiz.klock.*
+import korlibs.time.DateTime
+import korlibs.time.TimezoneOffset
 import dev.inmo.krontab.KronScheduler
-import dev.inmo.krontab.utils.copy
 
 /**
  * @param daysOfWeek 0-6
  * @param years any int
  * @param months 0-11
- * @param daysOfMonth 0-31
+ * @param daysOfMonth 0-30
  * @param hours 0-23
  * @param minutes 0-59
  * @param seconds 0-59
@@ -20,7 +20,8 @@ internal data class CronDateTime(
     val daysOfMonth: Array<Byte>? = null,
     val hours: Array<Byte>? = null,
     val minutes: Array<Byte>? = null,
-    val seconds: Array<Byte>? = null
+    val seconds: Array<Byte>? = null,
+    val milliseconds: Array<Short>? = millisecondsArrayDefault
 ) {
     init {
         check(daysOfWeek ?.all { it in dayOfWeekRange } ?: true)
@@ -30,12 +31,13 @@ internal data class CronDateTime(
         check(hours?.all { it in hoursRange } ?: true)
         check(minutes?.all { it in minutesRange } ?: true)
         check(seconds?.all { it in secondsRange } ?: true)
+        check(milliseconds?.all { it in millisecondsRange } ?: true)
     }
 
     internal val calculators = listOf(
         years ?.let { NearDateTimeCalculatorYears(it) },
         daysOfWeek ?.let { NearDateTimeCalculatorWeekDays(it) },
-        NearDateTimeCalculatorMillis(arrayOf(0)),
+        milliseconds ?.let { NearDateTimeCalculatorMillis(it) },
         seconds ?.let { NearDateTimeCalculatorSeconds(it) },
         minutes ?.let { NearDateTimeCalculatorMinutes(it) },
         hours ?.let { NearDateTimeCalculatorHours(it) },
@@ -65,9 +67,10 @@ internal fun createCronDateTime(
     dayOfMonth: Array<Byte>? = null,
     month: Array<Byte>? = null,
     years: Array<Int>? = null,
-    weekDays: Array<Byte>? = null
+    weekDays: Array<Byte>? = null,
+    milliseconds: Array<Short>? = millisecondsArrayDefault
 ): CronDateTime {
-    return CronDateTime(weekDays, years, month, dayOfMonth, hours, minutes, seconds)
+    return CronDateTime(weekDays, years, month, dayOfMonth, hours, minutes, seconds, milliseconds)
 }
 
 /**
@@ -80,8 +83,20 @@ internal fun createKronScheduler(
     dayOfMonth: Array<Byte>? = null,
     month: Array<Byte>? = null,
     years: Array<Int>? = null,
-    weekDays: Array<Byte>? = null
-): KronScheduler = CronDateTimeScheduler(createCronDateTime(seconds, minutes, hours, dayOfMonth, month, years, weekDays))
+    weekDays: Array<Byte>? = null,
+    milliseconds: Array<Short>? = millisecondsArrayDefault
+): KronScheduler = CronDateTimeScheduler(
+    createCronDateTime(
+        seconds,
+        minutes,
+        hours,
+        dayOfMonth,
+        month,
+        years,
+        weekDays,
+        milliseconds
+    )
+)
 /**
  * @return [KronScheduler] (in fact [CronDateTimeScheduler]) based on incoming data
  */
@@ -93,8 +108,21 @@ internal fun createKronSchedulerWithOffset(
     month: Array<Byte>? = null,
     years: Array<Int>? = null,
     weekDays: Array<Byte>? = null,
-    offset: TimezoneOffset
-): KronScheduler = CronDateTimeSchedulerTz(createCronDateTime(seconds, minutes, hours, dayOfMonth, month, years, weekDays), offset)
+    offset: TimezoneOffset,
+    milliseconds: Array<Short>? = millisecondsArrayDefault
+): KronScheduler = CronDateTimeSchedulerTz(
+    createCronDateTime(
+        seconds,
+        minutes,
+        hours,
+        dayOfMonth,
+        month,
+        years,
+        weekDays,
+        milliseconds
+    ),
+    offset
+)
 
 internal fun List<CronDateTime>.merge() = CronDateTime(
     flatMap { it.daysOfWeek ?.toList() ?: emptyList() }.distinct().toTypedArray().takeIf { it.isNotEmpty() },
@@ -104,4 +132,5 @@ internal fun List<CronDateTime>.merge() = CronDateTime(
     flatMap { it.hours ?.toList() ?: emptyList() }.distinct().toTypedArray().takeIf { it.isNotEmpty() },
     flatMap { it.minutes ?.toList() ?: emptyList() }.distinct().toTypedArray().takeIf { it.isNotEmpty() },
     flatMap { it.seconds ?.toList() ?: emptyList() }.distinct().toTypedArray().takeIf { it.isNotEmpty() },
+    flatMap { it.milliseconds ?.toList() ?: listOf(0) }.distinct().toTypedArray().takeIf { it.isNotEmpty() },
 )

src/commonMain/kotlin/dev/inmo/krontab/internal/CronDateTimeScheduler.kt

@@ -1,13 +1,13 @@
 package dev.inmo.krontab.internal
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.krontab.KronScheduler
-import dev.inmo.krontab.collection.plus
 
 /**
  * Cron-oriented realisation of [KronScheduler]
  *
  * @see dev.inmo.krontab.AnyTimeScheduler
+ * @see dev.inmo.krontab.EveryMillisecondScheduler
  * @see dev.inmo.krontab.EverySecondScheduler
  * @see dev.inmo.krontab.EveryMinuteScheduler
  * @see dev.inmo.krontab.EveryHourScheduler
@@ -36,23 +36,3 @@ internal fun mergeCronDateTimeSchedulers(
 ): CronDateTimeScheduler = CronDateTimeScheduler(
     schedulers.map { it.cronDateTime }.merge()
 )
-
-/**
- * @return New instance of [CronDateTimeScheduler] with all unique [CronDateTimeScheduler.cronDateTimes] of
- * [kronSchedulers] included
- */
-@Deprecated("Will be removed in next major release", ReplaceWith("merge", "dev.inmo.krontab"))
-fun merge(kronSchedulers: List<KronScheduler>) = kronSchedulers.apply { dev.inmo.krontab.merge() }
-
-/**
- * @return Vararg shortcut for [dev.inmo.krontab.merge]
- */
-@Suppress("NOTHING_TO_INLINE")
-@Deprecated("Will be removed in next major release", ReplaceWith("merge", "dev.inmo.krontab"))
-inline fun merge(vararg kronDateTimeSchedulers: KronScheduler) = kronDateTimeSchedulers.apply { dev.inmo.krontab.merge() }
-/**
- * @return Vararg shortcut for [dev.inmo.krontab.merge]
- */
-@Suppress("NOTHING_TO_INLINE")
-@Deprecated("Will be removed in next major release", ReplaceWith("merge", "dev.inmo.krontab"))
-inline fun KronScheduler.plus(other: KronScheduler) = this + other

src/commonMain/kotlin/dev/inmo/krontab/internal/CronDateTimeSchedulerTz.kt

@@ -1,7 +1,8 @@
 package dev.inmo.krontab.internal
 
-import com.soywiz.klock.DateTimeTz
-import com.soywiz.klock.TimezoneOffset
+import korlibs.time.DateTime
+import korlibs.time.DateTimeTz
+import korlibs.time.TimezoneOffset
 import dev.inmo.krontab.KronScheduler
 import dev.inmo.krontab.KronSchedulerTz
 
@@ -18,6 +19,10 @@ internal data class CronDateTimeSchedulerTz internal constructor(
         val dateTimeWithActualOffset = relatively.toOffset(offset).local
         return cronDateTime.toNearDateTime(dateTimeWithActualOffset) ?.toOffsetUnadjusted(offset) ?.toOffset(relatively.offset)
     }
+
+    override suspend fun next(relatively: DateTime): DateTime? {
+        return next(relatively.toOffset(offset)) ?.utc
+    }
 }
 
 internal fun mergeCronDateTimeSchedulers(

src/commonMain/kotlin/dev/inmo/krontab/internal/Defaults.kt

@@ -0,0 +1,4 @@
+package dev.inmo.krontab.internal
+
+internal const val millisecondsDefault: Short = 0
+internal val millisecondsArrayDefault: Array<Short> = arrayOf(millisecondsDefault)

src/commonMain/kotlin/dev/inmo/krontab/internal/NearDateTimeCalculator.kt

@@ -1,6 +1,6 @@
 package dev.inmo.krontab.internal
 
-import com.soywiz.klock.*
+import korlibs.time.*
 import dev.inmo.krontab.utils.copy
 import kotlin.math.min
 
@@ -101,13 +101,14 @@ internal fun NearDateTimeCalculatorDays(
     times: Array<Byte>
 ) = CommonNearDateTimeCalculator(
     times,
-    { it.dayOfMonth.toByte() },
+    { (it.dayOfMonth - 1).toByte() }, // index1, so, decrease
     { dateTime, newOne ->
-        (if (newOne < dateTime.dayOfMonth) {
+        val dateTime = (if (newOne < dateTime.dayOfMonth) {
             dateTime.plus(1.months)
         } else {
             dateTime
-        }).copy(
+        })
+        dateTime.copy(
             dayOfMonth = min(dateTime.month.days(dateTime.year), newOne.toInt() + 1), // index1
             hour = 0,
             minute = 0,
@@ -121,7 +122,7 @@ internal fun NearDateTimeCalculatorMonths(
     times: Array<Byte>
 ) = CommonNearDateTimeCalculator(
     times,
-    { it.dayOfMonth.toByte() },
+    { it.month0.toByte() },
     { dateTime, newOne ->
         (if (newOne < dateTime.month0) {
             dateTime.plus(1.years)

src/commonMain/kotlin/dev/inmo/krontab/internal/Parser.kt

@@ -3,6 +3,7 @@ package dev.inmo.krontab.internal
 typealias Converter<T> = (Int) -> T
 
 internal val intToByteConverter: Converter<Byte> = { it: Int -> it.toByte() }
+internal val intToShortConverter: Converter<Short> = { it: Int -> it.toShort() }
 internal val intToIntConverter: Converter<Int> = { it: Int -> it }
 private fun <T> createSimpleScheduler(from: String, dataRange: IntRange, dataConverter: Converter<T>): List<T>? {
     val things = from.split(",")
@@ -44,6 +45,7 @@ internal fun parseDaysOfMonth(from: String) = createSimpleScheduler(from, dayOfM
 internal fun parseHours(from: String) = createSimpleScheduler(from, hoursRange, intToByteConverter) ?.toTypedArray()
 internal fun parseMinutes(from: String) = createSimpleScheduler(from, minutesRange, intToByteConverter) ?.toTypedArray()
 internal fun parseSeconds(from: String) = createSimpleScheduler(from, secondsRange, intToByteConverter) ?.toTypedArray()
+internal fun parseMilliseconds(from: String?) = from ?.let { if (it.endsWith("ms")) createSimpleScheduler(from.removeSuffix("ms"), millisecondsRange, intToShortConverter) ?.toTypedArray() else null }
 
 internal fun <T> Array<T>.fillWith(
     whereToPut: MutableList<CronDateTime>,

src/commonMain/kotlin/dev/inmo/krontab/internal/Ranges.kt

@@ -7,3 +7,4 @@ internal val dayOfMonthRange = 0 .. 30
 internal val hoursRange = 0 .. 23
 internal val minutesRange = 0 .. 59
 internal val secondsRange = minutesRange
+internal val millisecondsRange = 0 .. 999

src/commonMain/kotlin/dev/inmo/krontab/utils/DateTimeCopy.kt

@@ -1,6 +1,7 @@
 package dev.inmo.krontab.utils
 
-import com.soywiz.klock.*
+import korlibs.time.DateTime
+import korlibs.time.Month
 import kotlin.math.min
 
 fun DateTime.copy(

src/commonMain/kotlin/dev/inmo/krontab/utils/SchedulerFlow.kt

@@ -1,58 +1,91 @@
 package dev.inmo.krontab.utils
 
-import com.soywiz.klock.DateTime
-import com.soywiz.klock.DateTimeTz
+import korlibs.time.DateTime
+import korlibs.time.DateTimeTz
+import korlibs.time.milliseconds
 import dev.inmo.krontab.KronScheduler
 import dev.inmo.krontab.next
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.isActive
 
 /**
- * This [Flow] will trigger emitting each near time which will be returned from [this] [KronScheduler] with attention to
- * time zones
+ * **This flow is [cold](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/)**
  *
- * @see channelFlow
+ * Will emit all the [KronScheduler.next] as soon as possible. In case [KronScheduler.next] return null, flow will
+ * be completed
+ *
+ * @param since Will be used as the first parameter for [KronScheduler.next] fun
  */
-@FlowPreview
-fun KronScheduler.asTzFlow(): Flow<DateTimeTz> = channelFlow {
-    var previousTime = DateTime.nowLocal()
-    while (isActive) {
-        val now = DateTime.nowLocal()
-        val nextTime = next(now) ?: break
-        if (previousTime == nextTime) {
-            delay(1L) // skip 1ms
-            continue
-        } else {
-            previousTime = nextTime
-        }
-        val sleepDelay = (nextTime - DateTime.now().local).millisecondsLong
-        delay(sleepDelay)
-        send(nextTime)
+fun KronScheduler.asTzFlowWithoutDelays(since: DateTimeTz = DateTime.nowLocal()): Flow<DateTimeTz> = flow {
+    var previous = since
+    while (currentCoroutineContext().isActive) {
+        val next = next(previous) ?: break
+        emit(next)
+        previous = next + 1.milliseconds
     }
 }
 
 /**
- * This method is a map for [asTzFlow] and will works the same but return flow with [DateTime]s
+ * **This flow is [cold](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/)**
+ *
+ * This [Flow] will use [asTzFlowWithoutDelays], but stop on each time until this time will happen
  */
-@FlowPreview
-fun KronScheduler.asFlow(): Flow<DateTime> = asTzFlow().map { it.local }
+fun KronScheduler.asTzFlowWithDelays(): Flow<DateTimeTz> = asTzFlowWithoutDelays().onEach { futureHappenTime ->
+    val now = DateTime.nowLocal()
 
+    delay((futureHappenTime - now).millisecondsLong)
+}
+
+/**
+ * **This flow is [cold](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/)**
+ *
+ * This [Flow] will use [asTzFlowWithoutDelays], but stop on each time until this time will happen
+ */
 @Deprecated(
-    "It is not recommended to use this class in future. This functionality will be removed soon",
-    ReplaceWith("asFlow", "dev.inmo.krontab.utils.asFlow")
+    "Behaviour will be changed. In some of near versions this flow will not delay executions",
+    ReplaceWith("this.asTzFlowWithDelays()", "dev.inmo.krontab.utils.asTzFlowWithDelays")
 )
-@FlowPreview
-class SchedulerFlow(
-    private val scheduler: KronScheduler
-) : AbstractFlow<DateTime>() {
-    @FlowPreview
-    override suspend fun collectSafely(collector: FlowCollector<DateTime>) {
-        while (true) {
-            val now = DateTime.now()
-            val nextTime = scheduler.next(now) ?: break
-            val sleepDelay = (nextTime - now).millisecondsLong
-            delay(sleepDelay)
-            collector.emit(nextTime)
-        }
+fun KronScheduler.asTzFlow(): Flow<DateTimeTz> = asTzFlowWithDelays()
+
+/**
+ * **This flow is [cold](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/)**
+ *
+ * Will emit all the [KronScheduler.next] as soon as possible. In case [KronScheduler.next] return null, flow will
+ * be completed
+ *
+ * @param since Will be used as the first parameter for [KronScheduler.next] fun
+ */
+fun KronScheduler.asFlowWithoutDelays(since: DateTime = DateTime.now()): Flow<DateTime> = flow {
+    var previous = since
+    while (currentCoroutineContext().isActive) {
+        val next = next(previous) ?: break
+        emit(next)
+        previous = next + 1.milliseconds
     }
 }
+
+/**
+ * **This flow is [cold](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/)**
+ *
+ * This [Flow] will use [asFlowWithoutDelays], but stop on each time until this time will happen
+ */
+fun KronScheduler.asFlowWithDelays(): Flow<DateTime> = asFlowWithoutDelays().onEach { futureHappenTime ->
+    val now = DateTime.now()
+
+    delay((futureHappenTime - now).millisecondsLong)
+}
+
+/**
+ * **This flow is [cold](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/)**
+ *
+ * This [Flow] will use [asFlowWithDelays], but stop on each time until this time will happen
+ */
+@Deprecated(
+    "Behaviour will be changed. In some of near versions this flow will not delay executions",
+    ReplaceWith("this.asFlowWithDelays()", "dev.inmo.krontab.utils.asFlowWithDelays")
+)
+fun KronScheduler.asFlow(): Flow<DateTime> = asFlowWithDelays()

src/commonMain/kotlin/dev/inmo/krontab/utils/flows/DateTimeFilters.kt

@@ -0,0 +1,34 @@
+package dev.inmo.krontab.utils.flows
+
+import korlibs.time.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.filter
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.filterSeconds(vararg seconds: Int) = filter { it.seconds in seconds }
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.filterMinutes(vararg minutes: Int) = filter { it.minutes in minutes }
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.filterHours(vararg hours: Int) = filter { it.hours in hours }
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.filterDaysOfMonths(vararg daysOfMonths: Int) = filter { it.dayOfMonth in daysOfMonths }
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.filterMonths(vararg months: Month) = filter { it.month in months }
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.filterMonths0(vararg months: Int) = filter { it.month0 in months }
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.filterMonths1(vararg months: Int) = filter { it.month1 in months }
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.filterYears(year: Year) = filter { it.year == year }
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.filterYears(vararg years: Int) = filter { it.yearInt in years }
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.filterWeekDays(vararg weekDays: DayOfWeek) = filter { it.dayOfWeek in weekDays }
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.filterWeekDays(vararg weekDays: Int) = filter { it.dayOfWeekInt in weekDays }

src/commonMain/kotlin/dev/inmo/krontab/utils/flows/DateTimeTzFilters.kt

@@ -0,0 +1,34 @@
+package dev.inmo.krontab.utils.flows
+
+import korlibs.time.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.filter
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.filterSeconds(vararg seconds: Int) = filter { it.seconds in seconds }
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.filterMinutes(vararg minutes: Int) = filter { it.minutes in minutes }
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.filterHours(vararg hours: Int) = filter { it.hours in hours }
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.filterDaysOfMonths(vararg daysOfMonths: Int) = filter { it.dayOfMonth in daysOfMonths }
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.filterMonths(vararg months: Month) = filter { it.month in months }
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.filterMonths0(vararg months: Int) = filter { it.month0 in months }
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.filterMonths1(vararg months: Int) = filter { it.month1 in months }
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.filterYears(year: Year) = filter { it.year == year }
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.filterYears(vararg years: Int) = filter { it.yearInt in years }
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.filterWeekDays(vararg weekDays: DayOfWeek) = filter { it.dayOfWeek in weekDays }
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.filterWeekDays(vararg weekDays: Int) = filter { it.dayOfWeekInt in weekDays }

src/commonMain/kotlin/dev/inmo/krontab/utils/flows/DateTimeTzWhen.kt

@@ -0,0 +1,25 @@
+package dev.inmo.krontab.utils.flows
+
+import korlibs.time.*
+import kotlinx.coroutines.flow.Flow
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.onlyStartsOfMinutes() = filterSeconds(0)
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.onlyStartsOfHours() = filterMinutes(0).onlyStartsOfMinutes()
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.onlyStartsOfDays() = filterHours(0).onlyStartsOfHours()
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.onlyStartsOfMondays() = filterWeekDays(DayOfWeek.Monday).onlyStartsOfDays()
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.onlyStartsOfSundays() = filterWeekDays(DayOfWeek.Sunday).onlyStartsOfDays()
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.onlyStartsOfMonths() = filterDaysOfMonths(1).onlyStartsOfDays()
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTime>.onlyStartsOfYears() = filterMonths(Month.January).onlyStartsOfMonths()

src/commonMain/kotlin/dev/inmo/krontab/utils/flows/DateTimeWhen.kt

@@ -0,0 +1,25 @@
+package dev.inmo.krontab.utils.flows
+
+import korlibs.time.*
+import kotlinx.coroutines.flow.Flow
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.onlyStartsOfMinutes() = filterSeconds(0)
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.onlyStartsOfHours() = filterMinutes(0).onlyStartsOfMinutes()
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.onlyStartsOfDays() = filterHours(0).onlyStartsOfHours()
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.onlyStartsOfMondays() = filterWeekDays(DayOfWeek.Monday).onlyStartsOfDays()
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.onlyStartsOfSundays() = filterWeekDays(DayOfWeek.Sunday).onlyStartsOfDays()
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.onlyStartsOfMonths() = filterDaysOfMonths(1).onlyStartsOfDays()
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun Flow<DateTimeTz>.onlyStartsOfYears() = filterMonths(Month.January).onlyStartsOfMonths()

src/commonTest/kotlin/dev/inmo/krontab/utils/CheckMonthsAndDaysCorrectWork.kt

@@ -0,0 +1,23 @@
+package dev.inmo.krontab.utils
+
+import korlibs.time.DateTime
+import korlibs.time.days
+import dev.inmo.krontab.buildSchedule
+import kotlinx.coroutines.test.runTest
+import kotlin.test.*
+
+class CheckMonthsAndDaysCorrectWork {
+    @Test
+    fun checkMonthsAndDaysCorrectWork() {
+        val now = DateTime.now().startOfYear.startOfDay
+        for (i in 0 until now.year.days) {
+            val scheduleDateTime = (now + i.days)
+            runTest {
+                assertEquals(
+                    scheduleDateTime,
+                    buildSchedule("0 0 0 ${scheduleDateTime.dayOfMonth - 1} ${scheduleDateTime.month0}").next(now)
+                )
+            }
+        }
+    }
+}

src/commonTest/kotlin/dev/inmo/krontab/utils/FailJob.kt

@@ -1,6 +1,8 @@
 package dev.inmo.krontab.utils
 
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 
 fun CoroutineScope.createFailJob(forTimeMillis: Long) = launch {
     delay(forTimeMillis)

src/commonTest/kotlin/dev/inmo/krontab/utils/RunTest.kt

@@ -1,8 +0,0 @@
-package dev.inmo.krontab.utils
-
-import kotlinx.coroutines.CoroutineScope
-
-/**
- * Workaround to use suspending functions in unit tests
- */
-expect fun runTest(block: suspend (scope : CoroutineScope) -> Unit)

src/commonTest/kotlin/dev/inmo/krontab/utils/SchedulerFlow.kt

@@ -2,8 +2,8 @@ package dev.inmo.krontab.utils
 
 import dev.inmo.krontab.builder.buildSchedule
 import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.takeWhile
+import kotlinx.coroutines.test.runTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
@@ -18,7 +18,7 @@ class SchedulerFlowTests {
             }
         }
 
-        val flow = kronScheduler.asFlow()
+        val flow = kronScheduler.asFlowWithoutDelays()
 
         runTest {
             val mustBeCollected = 10
@@ -40,14 +40,14 @@ class SchedulerFlowTests {
             }
         }
 
-        val flow = kronScheduler.asFlow()
+        val flow = kronScheduler.asFlowWithoutDelays()
 
         runTest {
             val testsCount = 10
-            val failJob = it.createFailJob((testsCount * 2) * 1000L)
+            val failJob = createFailJob((testsCount * 2) * 1000L)
             val mustBeCollected = 10
             val answers = (0 until testsCount).map { _ ->
-                it.async {
+                async {
                     var collected = 0
                     flow.takeWhile {
                         collected < mustBeCollected

src/commonTest/kotlin/dev/inmo/krontab/utils/StringParseTest.kt

@@ -1,13 +1,12 @@
 package dev.inmo.krontab.utils
 
-import com.soywiz.klock.*
+import korlibs.time.*
 import dev.inmo.krontab.KronSchedulerTz
 import dev.inmo.krontab.buildSchedule
 import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.takeWhile
-import kotlin.test.Test
-import kotlin.test.assertEquals
+import kotlinx.coroutines.test.runTest
+import kotlin.test.*
 
 @ExperimentalCoroutinesApi
 @FlowPreview
@@ -16,7 +15,24 @@ class StringParseTest {
     fun testThatFlowIsCorrectlyWorkEverySecondBuiltOnString() {
         val kronScheduler = buildSchedule("*/1 * * * *")
 
-        val flow = kronScheduler.asFlow()
+        val flow = kronScheduler.asFlowWithoutDelays()
+
+        runTest {
+            val mustBeCollected = 10
+            var collected = 0
+            flow.takeWhile {
+                collected < mustBeCollected
+            }.collect {
+                collected++
+            }
+            assertEquals(mustBeCollected, collected)
+        }
+    }
+    @Test
+    fun testThatFlowIsCorrectlyWorkEverySecondWhenMillisIsHalfOfSecondBuiltOnString() {
+        val kronScheduler = buildSchedule("*/1 * * * * 500ms")
+
+        val flow = kronScheduler.asFlowWithoutDelays()
 
         runTest {
             val mustBeCollected = 10
@@ -34,14 +50,14 @@ class StringParseTest {
     fun testThatFlowIsCorrectlyWorkEverySecondWithMuchOfEmittersBuiltOnString() {
         val kronScheduler = buildSchedule("*/1 * * * *")
 
-        val flow = kronScheduler.asFlow()
+        val flow = kronScheduler.asFlowWithoutDelays()
 
         runTest {
             val testsCount = 10
-            val failJob = it.createFailJob((testsCount * 2) * 1000L)
+            val failJob = createFailJob((testsCount * 2) * 1000L)
             val mustBeCollected = 10
             val answers = (0 until testsCount).map { _ ->
-                it.async {
+                async {
                     var collected = 0
                     flow.takeWhile {
                         collected < mustBeCollected
@@ -64,7 +80,7 @@ class StringParseTest {
         val rangesEnds = listOf(0 to 5, 30 to 35)
         val kronScheduler = buildSchedule("${rangesEnds.joinToString(",") { "${it.first}-${it.second}" }} * * * *")
 
-        val flow = kronScheduler.asFlow()
+        val flow = kronScheduler.asFlowWithoutDelays()
 
         runTest {
             val ranges = rangesEnds.map { it.first .. it.second }.flatten().distinct().toMutableList()
@@ -74,6 +90,32 @@ class StringParseTest {
             flow.takeWhile { ranges.isNotEmpty() }.collect {
                 ranges.remove(it.seconds)
                 collected++
+                assertTrue(
+                    collected <= expectedCollects,
+                    "Expected value should be less than $expectedCollects, but was $collected. Ranges state: $ranges"
+                )
+            }
+            assertEquals(expectedCollects, collected)
+        }
+    }
+    @Test
+    fun testNextIsCorrectlyWorkEverySeveralMillisecondsRangeBuiltOnString() {
+        val rangesEnds = listOf(0, 200, 500, 750)
+        val kronScheduler = buildSchedule("* * * * * ${rangesEnds.joinToString(",") { "$it" }}ms")
+
+        runTest {
+            val ranges = rangesEnds.toMutableList()
+            val expectedCollects = ranges.size
+            var collected = 0
+
+            var currentTime = DateTime.now()
+            while (ranges.isNotEmpty()) {
+                val nextTrigger = kronScheduler.next(currentTime) ?: error("Strangely unable to get next time")
+
+                ranges.remove(nextTrigger.milliseconds)
+                collected++
+
+                currentTime = nextTrigger + 1.milliseconds
             }
             assertEquals(expectedCollects, collected)
         }

src/commonTest/kotlin/dev/inmo/krontab/utils/TimeZoneTest.kt

@@ -1,8 +1,9 @@
 package dev.inmo.krontab.utils
 
-import com.soywiz.klock.*
+import korlibs.time.*
 import dev.inmo.krontab.builder.buildSchedule
 import dev.inmo.krontab.next
+import kotlinx.coroutines.test.runTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
 

src/commonTest/kotlin/dev/inmo/krontab/utils/WeekDaysTest.kt

@@ -1,7 +1,8 @@
 package dev.inmo.krontab.utils
 
-import com.soywiz.klock.*
+import korlibs.time.*
 import dev.inmo.krontab.builder.buildSchedule
+import kotlinx.coroutines.test.runTest
 import kotlin.math.ceil
 import kotlin.test.*
 

src/jsTest/kotlin/dev/inmo/krontab/utils/RunTest.kt

@@ -1,5 +0,0 @@
-package dev.inmo.krontab.utils
-
-import kotlinx.coroutines.*
-
-actual fun runTest(block: suspend (scope : CoroutineScope) -> Unit): dynamic = GlobalScope.promise { block(this) }

src/jvmTest/kotlin/dev/inmo/krontab/utils/RunTest.kt

@@ -1,9 +0,0 @@
-package dev.inmo.krontab.utils
-
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.runBlocking
-
-/**
- * Workaround to use suspending functions in unit tests
- */
-actual fun runTest(block: suspend (scope: CoroutineScope) -> Unit) = runBlocking(block = block)

src/main/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest package="dev.inmo.krontab"/>

src/main/kotlin/dev/inmo/krontab/KronSchedulerWork.kt

@@ -2,7 +2,7 @@ package dev.inmo.krontab
 
 import android.content.Context
 import androidx.work.*
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import java.util.concurrent.TimeUnit
 
 /**