DEV Community: Ivan Karbashevskyi

🔁 createSharedPromise: Share In-Flight Async Calls with Elegance

Ivan Karbashevskyi — Wed, 30 Jul 2025 16:36:03 +0000

Have you ever triggered the same async request multiple times in parallel — like fetching a config or user profile — and wondered:

“Why are we hitting the server or database more than once when the data is the same?”

This pattern is common across servers and frontends, and it’s inefficient.

Let’s solve that with a super lightweight, zero-dependency, elegant utility:
createSharedPromise() — now optimized with minimal code, closure-based logic, and optional one-time delivery.

🚀 What Does It Do?

• Shares one Promise across multiple .then() calls
• Deduplicates parallel requests
• Caches the result after the first call
• Allows clearing the cache
• Fully thenable (works with await too)
• Optional { once: true } to flush callbacks after resolution

🧠 The Code (fully inline, zero-dependencies)

function createSharedPromise(asyncFunction, { once = false } = {}) {
  let inFlight = false;
  let cache = null;
  const fulfillRejectHandlers = [];

  const run = (argument, fulfillRejectFlag) => {
    if (once) {
      while (fulfillRejectHandlers.length) {
        const { [fulfillRejectFlag]: handler } = fulfillRejectHandlers.pop();
        handler?.(argument);
      }
    } else {
      fulfillRejectHandlers.forEach(
        ({ [fulfillRejectFlag]: handler }) => handler?.(argument)
      );
    }
  };

  return {
    clear() {
      cache = null;
    },
    then(onFulfilled, onRejected) {
      if (cache !== null) {
        onFulfilled?.(cache);
        return;
      }

      fulfillRejectHandlers.push([onFulfilled, onRejected]);

      if (inFlight) return;
      inFlight = true;

      asyncFunction()
        .then(result => {
          cache = result;
          inFlight = false;
          run(result, 0);
        })
        .catch(error => run(error, 1));
    }
  };
}

This version is tiny, elegant, and avoids unnecessary Promise wrapping or internal get() method exposure.

🧪 Try It Live in DevTools

function mockSlowFetch() {
  console.log('[mockFetch] Starting...');
  return new Promise(resolve =>
    setTimeout(() => {
      const res = { time: new Date().toISOString() };
      console.log('[mockFetch] Done:', res);
      resolve(res);
    }, 2000)
  );
}

const sharedFetcher = createSharedPromise(mockSlowFetch);

console.log('Calling sharedFetcher 3 times:');
sharedFetcher.then(r => console.log('Result 1:', r));
sharedFetcher.then(r => console.log('Result 2:', r));
(async () => {
  const r = await sharedFetcher;
  console.log('Result 3:', r);
})();

setTimeout(() => {
  console.log('Calling again (cached):');
  sharedFetcher.then(r => console.log('Result 4 (cached):', r));
}, 3000);

setTimeout(() => {
  console.log('Clearing and calling again...');
  sharedFetcher.clear();
  sharedFetcher.then(r => console.log('Result 5 (new):', r));
}, 6000);

🧩 Real-World Use Cases

1. 📦 Vanilla Node.js Server

import http from 'http';
import fs from 'fs/promises';

const configLoader = createSharedPromise(() =>
  fs.readFile('./config.json', 'utf-8').then(JSON.parse)
);

http.createServer(async (req, res) => {
  if (req.url === '/config') {
    configLoader.then(config => {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify(config));
    });
  }
}).listen(3000);

2. 🧱 NestJS Service (shared DB/API calls)

@Injectable()
export class ConfigService {
  private configFetcher = createSharedPromise(() =>
    this.httpService.get('https://api.example.com/config').toPromise().then(r => r.data)
  );

  getConfig(): Promise<any> {
    return this.configFetcher;
  }

  refresh() {
    this.configFetcher.clear();
  }
}

Usage:

await this.configService.getConfig();

3. 🧩 Angular Service

@Injectable({ providedIn: 'root' })
export class UserService {
  private profileFetcher = createSharedPromise(() =>
    this.http.get('/api/profile').toPromise()
  );

  constructor(private http: HttpClient) {}

  getProfile(): Promise<any> {
    return this.profileFetcher;
  }

  refreshProfile(): void {
    this.profileFetcher.clear();
  }
}

Use in component:

this.userService.getProfile().then(profile => this.profile = profile);

4. 🌍 Vanilla JS Frontend

<button id="loadConfig">Load Config</button>
<script type="module">
  const configFetcher = createSharedPromise(() =>
    fetch('/config.json').then(res => res.json())
  );

  document.getElementById('loadConfig').addEventListener(() => {
    configFetcher.then(config => {
      console.log('Loaded config:', config);
    });
  });
</script>

🔄 Optional: { once: true }

If { once: true } is passed, the callback queue will be flushed once, and not retained — useful for cases where memory usage matters, or when only one delivery is expected.

const oneTime = createSharedPromise(() => fetch('/data'), { once: true });

✅ Benefits Recap

✅ Promise deduplication
✅ .then() compatible
✅ await support (via then)
✅ Manual cache clear (.clear())
✅ One-time callbacks ({ once: true })
✅ Zero dependencies

🧠 Final Thoughts

This is an elegant solution for a common problem that can lead to:
• Better performance
• Lower server/API usage
• Cleaner architecture

Use it to wrap:
• HTTP calls
• DB queries
• Config loaders
• Feature flags
• Anything expensive and cacheable!

Unlock the Magic of is.lowerCase and is.not_lowerCase in JavaScript with 'thiis': Your Friendly Guide to String Checks

Ivan Karbashevskyi — Sat, 02 Dec 2023 11:37:17 +0000

JavaScript is a language of possibilities, and when it comes to handling strings, having tools that simplify the checks can make coding a joyous journey. Enter the is.lowerCase method from the 'thiis' package - your trusty sidekick for checking if a string is in lowercase. In this article, we'll explore the wonders of is.lowerCase along with its companion, is.not_lowerCase, in various scenarios that showcase their versatility and playfulness.

Embracing Lowercase in JavaScript

Before we dive into the magical world of is.lowerCase, let's take a moment to appreciate the importance of lowercase letters in strings. In JavaScript, strings are case-sensitive, and knowing whether a string is in lowercase or not can be crucial for validation, formatting, and more.

Meet `is.lowerCase` - Your Lowercase Guru

Documentation link

Imagine you're on a quest to ensure that a string is in all lowercase glory. The is.lowerCase method is your guru, here to confirm if a string is, indeed, in lowercase. Let's witness its magic:

import { is } from 'thiis';

const myString = 'hellothere';
const result = is.lowerCase(myString);

console.log(result); // true

In this example, we import the "is" object from the "thiis" package and use the is.lowerCase method to confirm that myString is indeed in lowercase. As expected, it returns true.

The Tale of Examples

Now, let's embark on a journey through several examples that showcase the charm of is.lowerCase and its companion, is.not_lowerCase. We'll explore six unique scenarios, including some playful combinations.

1. Basic Lowercase Validation

The primary role of is.lowerCase is to validate if a string is in lowercase. It helps you confirm when a string is all lowercase, which can be essential for consistent data:

import { is } from 'thiis';

const lowercaseString = 'hellothere';
const mixedCaseString = 'HelloThere';

console.log(is.lowerCase(lowercaseString)); // true
console.log(is.lowerCase(mixedCaseString)); // false

2. Guarding Against Lowercase

Conversely, is.not_lowerCase serves as your guardian against strings that are in lowercase. It's handy when you want to ensure that a string isn't in lowercase before proceeding:

import { is } from 'thiis';

const importantString = 'ImportantString';
const regularString = 'justaregularstring';

console.log(is.not_lowerCase(importantString)); // true
console.log(is.not_lowerCase(regularString)); // false

3. Creative Combos with `is.kebabCases_or_lowerCase`

Mixing and matching methods can be powerful. For instance, you can use is.kebabCases_or_lowerCase to check if a string is either in kebab case or all lowercase:

import { is } from 'thiis';

const kebabCaseString = 'kebab-case-string';
const randomString = 'RandomString';

console.log(is.kebabCases_or_lowerCase(kebabCaseString)); // true
console.log(is.kebabCases_or_lowerCase(randomString)); // false

4. Stream of Lowercase with `is.lowerCase`

Let's explore a scenario involving stream$ from RxJS. Using filter and is.lowerCase, we can ensure that the stream processes only strings in lowercase:

import { is } from 'thiis';
import { from } from 'rxjs';
import { filter } from 'rxjs/operators';

const stream$ = from(['lowercase', 'NotLowerCase', 'anotherlowercase']);

stream$
  .pipe(
    filter(value => is.lowerCase(value))
  )
  .subscribe(lowerCaseValue => {
    console.log(lowerCaseValue); // Only lowercase strings will be part of the stream's story.
  });

5. Array Exploration with `is.not_lowerCase`

Arrays are another playground for is.not_lowerCase. You can use every() to confirm that all elements are not in lowercase and some() to check if at least one isn't:

import { is } from 'thiis';

const notLowerCaseArray = ['Uppercase', 'NotLowerCase', 'RandomString'];
const mixedCaseArray = ['AnotherMixedCase', 'AlsoNotLowerCase', 'lowercase'];

const allElementsNotLowerCase = notLowerCaseArray.every(is.not_lowerCase); // true
const someElementsNotLowerCase = mixedCaseArray.some(is.not_lowerCase); // true

console.log(allElementsNotLowerCase);
console.log(someElementsNotLowerCase);

6. String Transformation with `is.lowerCase`

Sometimes, you might want to transform a string into lowercase only if it's not already in that form. is.lowerCase can guide your transformation decisions:

import { is } from 'thiis';

function transformToLowerCase(input) {
  return is.lowerCase(input) ? input : input.toLowerCase();
}

console.log(transformToLowerCase('AlreadyLowerCase')); // 'AlreadyLowerCase'
console.log(transformToLowerCase('MakeMeLowerCase')); // 'makemelowercase'

The Adventure Continues

The is.lowerCase and is.not_lowerCase methods from the 'thiis' package are your reliable companions on your JavaScript adventure. They make string checks playful and precise, ensuring your code interacts with lowercase strings exactly as intended. By adding the 'thiis' package to your JavaScript toolkit and exploring its documentation for more tips and examples, you can navigate the JavaScript landscape with confidence and creativity.

So, keep coding, and remember that the world of JavaScript is full of delightful discoveries!

Embracing Clean Code with `is.kebabCase` and `is.not_kebabCase` from 'thiis': A Fun Journey into String Formatting

Ivan Karbashevskyi — Thu, 30 Nov 2023 09:40:10 +0000

JavaScript is like a canvas for developers, and when it comes to string formatting, keeping things consistent can make your code a joy to read. Enter the is.kebabCase and is.not_kebabCase methods from the 'thiis' package, your companions on the road to cleaner and more readable code. In this article, we'll embark on a delightful journey exploring these methods through various examples, including some exciting combinations with other methods.

The Charm of Kebab Case in JavaScript

Before we set off on our adventure, let's talk about kebab case. In JavaScript, kebab case is a convention where words are separated by hyphens (-). It's often used in variable names, function names, and even URLs. is.kebabCase helps you ensure that a given string adheres to this convention.

Meet `is.kebabCase` - Your String Stylist

Documentation link

Imagine you have a string, and you want to check if it follows the elegant kebab case convention. The is.kebabCase method is like a stylist for your strings, making sure they are formatted correctly. Let's see it in action:

import { is } from 'thiis';

const myString = 'hello-world';
const result = is.kebabCase(myString);

console.log(result); // true

In this example, we use is.kebabCase to confirm that myString is indeed in kebab case. As expected, it returns true because the string follows the convention.

The Journey of Examples

Now, let's embark on a delightful journey exploring the capabilities of is.kebabCase and its playful partner, is.not_kebabCase. We'll delve into six unique scenarios, including a couple of exciting combinations.

1. Checking for Kebab Case

The primary purpose of is.kebabCase is to verify if a string follows the kebab case convention. It's perfect for ensuring consistent naming in your code:

import { is } from 'thiis';

const variableName = 'my-variable-name';
const isVariableKebab = is.kebabCase(variableName);

if (isVariableKebab) {
  // Proceed confidently with your kebab case variable.
} else {
  // Handle cases where the variable name doesn't adhere to kebab case.
}

2. Guarding Against Non-Kebab Case

On the flip side, is.not_kebabCase acts as your guardian against strings that don't follow the kebab case convention. Use it to catch non-kebab case strings before they sneak into your code:

import { is } from 'thiis';

const functionName = 'myFunctionName';
const isFunctionNotKebab = is.not_kebabCase(functionName);

if (isFunctionNotKebab) {
  // Handle scenarios where the function name isn't in kebab case.
} else {
  // Proceed with confidence.
}

3. Combining with Other Methods

Now, let's have some fun with combining methods. You can use logical OR (||) to check for multiple conventions, like kebab case or camel case:

import { is } from 'thiis';

const mixedCaseString = 'mixedCaseString';
const isMixedCase = is.kebabCase(mixedCaseString) || is.camelCase(mixedCaseString);

if (isMixedCase) {
  // Handle scenarios where the string is either kebab case or camel case.
} else {
  // Explore other possibilities.
}

4. Stream of Kebabs with `is.kebabCase`

Let's bring in a stream of strings and filter out those that are not in kebab case. This time, we're introducing RxJS and the filter operator:

import { is } from 'thiis';
import { from } from 'rxjs';
import { filter } from 'rxjs/operators';

const stream$ = from(['hello-world', 'notKebabCase', 'another-one', 'yet-another']);

stream$
  .pipe(
    filter(is.kebabCase)
  )
  .subscribe(kebabString => {
    console.log(kebabString); // Only kebab case strings will make it to the stream!
  });

In this example, the filter(is.kebabCase) ensures that only kebab case strings get processed by the stream.

5. Array Exploration with `is.not_kebabCase`

Arrays provide yet another playground for is.not_kebabCase. Check if any element in an array violates the kebab case convention:

import { is } from 'thiis';

const nonKebabArray = ['hello-world', 'notKebabCase', 'another-one', 'yet-another'];

const hasNonKebabElement = nonKebabArray.some(is.not_kebabCase); // true

console.log(hasNonKebabElement);

Here, hasNonKebabElement checks if at least one element in the array is not in kebab case.

6. Creative URL Validation

In the world of web development, ensuring kebab case in URLs is common. Use is.kebabCase for creative URL validation:

import { is } from 'thiis';

function validateURL(url) {
  if (is.kebabCase(url)) {
    return 'URL format is perfect!';
  } else {
    return 'Invalid URL format. Please use kebab case.';
  }
}

7. Additional examples

is.kebabCase('hello'); // true
is.kebabCase('hello123'); // true
is.kebabCase('undefined'); // true
is.kebabCase('null'); // true
is.kebabCase('a1-b2-c3-d4-e5-f'); // true
is.kebabCase('g1-h2-i3-j4-k5-l6'); // true
is.kebabCase('in-kebab-case'); // true

is.kebabCase('helloWorld'); // false
is.kebabCase('a1B2c3d4e5f6g'); // false
is.kebabCase('a1B2c3d4e5f6'); // false
is.kebabCase('inCamelCase'); // false
is.kebabCase(BigInt(1)) // false
is.kebabCase(0) // false
is.kebabCase(1) // false
is.kebabCase(-1) // false
is.kebabCase(Symbol()) // false
is.kebabCase(null) // false
is.kebabCase(true) // false
is.kebabCase([]) // false
is.kebabCase(false) // false
is.kebabCase("") // false
is.kebabCase('') // false
is.kebabCase(``) // false
is.kebabCase({}) // false
is.kebabCase(undefined) // false
is.kebabCase(Function) // false
is.kebabCase(() => {}) // false
is.kebabCase(BigInt) // false
is.kebabCase(Symbol) // false
is.kebabCase(NaN) // false
is.kebabCase(Infinity) // false
is.kebabCase(-Infinity) // false
is.kebabCase(Number.POSITIVE_INFINITY) // false
is.kebabCase(Number.NEGATIVE_INFINITY) // false
// And all other known types will return false

is.not_kebabCase('hello'); // false
is.not_kebabCase('hello123'); // false
is.not_kebabCase('undefined'); // false
is.not_kebabCase('null'); // false
is.not_kebabCase('a1-b2-c3-d4-e5-f'); // false
is.not_kebabCase('g1-h2-i3-j4-k5-l6'); // false
is.not_kebabCase('in-kebab-case'); // false

is.not_kebabCase('helloWorld'); // true
is.not_kebabCase('a1B2c3d4e5f6g'); // true
is.not_kebabCase('a1B2c3d4e5f6'); // true
is.not_kebabCase('inCamelCase'); // true
is.not_kebabCase(BigInt(1)) // true
is.not_kebabCase(0) // true
is.not_kebabCase(1) // true
is.not_kebabCase(-1) // true
is.not_kebabCase(Symbol()) // true
is.not_kebabCase(null) // true
is.not_kebabCase(true) // true
is.not_kebabCase([]) // true
is.not_kebabCase(false) // true
is.not_kebabCase("") // true
is.not_kebabCase('') // true
is.not_kebabCase(``) // true
is.not_kebabCase({}) // true
is.not_kebabCase(undefined) // true
is.not_kebabCase(Function) // true
is.not_kebabCase(() => {}) // true
is.not_kebabCase(BigInt) // true
is.not_kebabCase(Symbol) // true
is.not_kebabCase(NaN) // true
is.not_kebabCase(Infinity) // true
is.not_kebabCase(-Infinity) // true
is.not_kebabCase(Number.POSITIVE_INFINITY) // true
is.not_kebabCase(Number.NEGATIVE_INFINITY) // true
// And all other known types will return true

8. Combination example

is.kebabCase_or_upperCase(...)
is.snakeCase_or_kebabCase(...)
is.snakeCase_or_kebabCase_or_pascalCase(...)

The Adventure Continues

The is.kebabCase and is.not_kebabCase methods from the 'thiis' package are your delightful companions on your JavaScript journey. They make string formatting playful and precise, ensuring your code adheres to the kebab case convention. By adding the 'thiis' package to your JavaScript toolkit and exploring its documentation for more tips and examples, you can elevate the readability of your code while having a touch of fun.

So, keep formatting those strings, and may your code be as elegant as a well-formatted kebab!

Unraveling IPv6 with `is.ipv6` and `is.not_ipv6` in JavaScript: Navigating the Digital Highway

Ivan Karbashevskyi — Thu, 30 Nov 2023 09:23:25 +0000

Welcome to the world of IP addresses, where every device on the internet has its unique identifier. Among these identifiers, IPv6 stands out as a futuristic address, and handling it in JavaScript is a breeze with the is.ipv6 method and its trusty sidekick, is.not_ipv6 from the 'thiis' package. In this article, we'll embark on a journey to explore these tools, demystify IPv6, and sprinkle in some practical examples.

Understanding the IPv6 Landscape

Before we dive into the magical world of is.ipv6, let's briefly talk about IPv6. Internet Protocol version 6 (IPv6) is the latest version of the Internet Protocol. It provides a vastly expanded address space compared to its predecessor, IPv4, allowing for an almost limitless number of unique IP addresses.

Meet `is.ipv6` - Your IPv6 Navigator

Documentation link

Imagine you're on a quest to determine whether a given value is a valid IPv6 address. The is.ipv6 method is like your digital navigator, helping you sail smoothly through the IPv6 landscape. Let's witness its magic:

import { is } from 'thiis'; // Import the "is" object from the "thiis" package

const ipAddress = '2001:0db8:85a3:0000:0000:8a2e:0370:7334';
const result = is.ipv6(ipAddress);

console.log(result); // true

In this example, we import the "is" object from the "thiis" package and use the is.ipv6 method to confirm that ipAddress is indeed a valid IPv6 address. As expected, it returns true because the value is indeed a valid IPv6 address.

The Journey of Examples

Now, let's embark on a journey through practical examples that showcase the versatility of is.ipv6 and its companion, is.not_ipv6. We'll explore six unique scenarios, including an exciting duo involving stream$ and an array.

1. Validating IPv6 Addresses

The primary use of is.ipv6 is to validate whether a given string is a valid IPv6 address. This is crucial for handling user inputs or parsing data from external sources:

import { is } from 'thiis';

const userEnteredIP = getUserInput();

if (is.ipv6(userEnteredIP)) {
  // It's a valid IPv6 address! Proceed with confidence.
} else {
  // Handle invalid inputs gracefully.
}

2. Guarding Against Non-IPv6 Values

Conversely, is.not_ipv6 acts as your guardian against non-IPv6 values. Use it when you want to ensure that a value is not an IPv6 address before proceeding:

import { is } from 'thiis';

const potentialIPAddress = someFunctionThatMayReturnAnything();

if (is.not_ipv6(potentialIPAddress)) {
  // Guard against non-IPv6 values. Your digital guardian at work!
} else {
  // Continue exploring the IPv6 landscape.
}

3. Handling IPv6 in Stream$

Let's integrate our IPv6 navigator into an RxJS stream. Using filter and is.ipv6, we can ensure that the stream processes only valid IPv6 addresses:

import { is } from 'thiis';
import { from } from 'rxjs';
import { filter } from 'rxjs/operators';

const ipv6Stream$ = from(['2001:0db8::1', 'notIPv6', 'fe80::1', 'anotherOne']);

ipv6Stream$
  .pipe(
    filter(is.ipv6)
  )
  .subscribe(ipv6Address => {
    console.log(ipv6Address); // Only valid IPv6 addresses will be part of the stream's journey.
  });

Here, the filter(is.ipv6) ensures that only valid IPv6 addresses get processed by the stream.

4. Checking an Array of IP Addresses

Arrays are another playground for is.ipv6. Use every() to confirm that all elements are valid IPv6 addresses, and some() to check if at least one is:

import { is } from 'thiis';

const ipv6Addresses = ['2001:0db8::1', 'fe80::1', 'notIPv6', 'anotherOne'];

const allAreIPv6 = ipv6Addresses.every(is.ipv6); // false
const someAreIPv6 = ipv6Addresses.some(is.ipv6); // true

console.log(allAreIPv6);
console.log(someAreIPv6);

In this example, allAreIPv6 checks if all elements in ipv6Addresses are valid IPv6 addresses, and someAreIPv6 checks if at least one is.

5. Additional examples

is.ipv6('2001:0db8:85a3:0000:0000:8a2e:0370:7334') // true
is.ipv6('2001:db8:0:0:0:0:2:1') // true
is.ipv6('2001:db8::2:1') // true
is.ipv6('::') // true
is.ipv6('::1') // true
is.ipv6('::ffff:192.0.2.128') // true
is.ipv6('2001:db8::567:1') // true

is.ipv6('192.168.1.1'); // false
is.ipv6('255.255.255.0'); // false
is.ipv6('10.0.0.1'); // false
is.ipv6('172.16.0.1'); // false
is.ipv6(`a`); // false
is.ipv6("r"); // false
is.ipv6('t'); // false
is.ipv6(`3`); // false
is.ipv6(`1`); // false
is.ipv6(`2`); // false
is.ipv6('hello'); // false
is.ipv6('hello123'); // false
is.ipv6('helloWorld'); // false
is.ipv6('a1B2c3d4e5f6g'); // false
is.ipv6('a1B2c3d4e5f6'); // false
is.ipv6('inCamelCase'); // false
is.ipv6('undefined'); // false
is.ipv6('null'); // false
is.ipv6(BigInt(1)) // false
is.ipv6(0) // false
is.ipv6(1) // false
is.ipv6(-1) // false
is.ipv6(Symbol()) // false
is.ipv6(null) // false
is.ipv6(true) // false
is.ipv6([]) // false
is.ipv6(false) // false
is.ipv6("") // false
is.ipv6('') // false
is.ipv6(``) // false
is.ipv6({}) // false
is.ipv6(undefined) // false
is.ipv6(Function) // false
is.ipv6(() => {}) // false
is.ipv6(BigInt) // false
is.ipv6(Symbol) // false
is.ipv6(NaN) // false
is.ipv6(Infinity) // false
is.ipv6(-Infinity) // false
is.ipv6(Number.POSITIVE_INFINITY) // false
is.ipv6(Number.NEGATIVE_INFINITY) // false
// And all other known types will return false

is.not_ipv6('2001:0db8:85a3:0000:0000:8a2e:0370:7334') // false
is.not_ipv6('2001:db8:0:0:0:0:2:1') // false
is.not_ipv6('2001:db8::2:1') // false
is.not_ipv6('::') // false
is.not_ipv6('::1') // false
is.not_ipv6('::ffff:192.0.2.128') // false
is.not_ipv6('2001:db8::567:1') // false

is.not_ipv6('192.168.1.1'); // true
is.not_ipv6('255.255.255.0'); // true
is.not_ipv6('10.0.0.1'); // true
is.not_ipv6('172.16.0.1'); // true
is.not_ipv6(`a`); // true
is.not_ipv6("r"); // true
is.not_ipv6('t'); // true
is.not_ipv6(`3`); // true
is.not_ipv6(`1`); // true
is.not_ipv6(`2`); // true
is.not_ipv6('hello'); // true
is.not_ipv6('hello123'); // true
is.not_ipv6('helloWorld'); // true
is.not_ipv6('a1B2c3d4e5f6g'); // true
is.not_ipv6('a1B2c3d4e5f6'); // true
is.not_ipv6('inCamelCase'); // true
is.not_ipv6('undefined'); // true
is.not_ipv6('null'); // true
is.not_ipv6(BigInt(1)) // true
is.not_ipv6(0) // true
is.not_ipv6(1) // true
is.not_ipv6(-1) // true
is.not_ipv6(Symbol()) // true
is.not_ipv6(null) // true
is.not_ipv6(true) // true
is.not_ipv6([]) // true
is.not_ipv6(false) // true
is.not_ipv6("") // true
is.not_ipv6('') // true
is.not_ipv6(``) // true
is.not_ipv6({}) // true
is.not_ipv6(undefined) // true
is.not_ipv6(Function) // true
is.not_ipv6(() => {}) // true
is.not_ipv6(BigInt) // true
is.not_ipv6(Symbol) // true
is.not_ipv6(NaN) // true
is.not_ipv6(Infinity) // true
is.not_ipv6(-Infinity) // true
is.not_ipv6(Number.POSITIVE_INFINITY) // true
is.not_ipv6(Number.NEGATIVE_INFINITY) // true
// And all other known types will return true

6. Combination example

is.ipv4_or_ipv6('2001:db8:0:0:0:0:2:1') // true
is.ipv6_or_ipv4('2001:db8:0:0:0:0:2:1') // true

The Adventure Continues

The is.ipv6 and is.not_ipv6 methods from the 'thiis' package are your trusty guides on the digital highway of JavaScript. They make handling IPv6 addresses easy and ensure your code interacts with them exactly as intended. By adding the 'thiis' package to your JavaScript toolkit and exploring its documentation for more tips and examples, you can navigate the IPv6 landscape with confidence and a sense of adventure.

So, keep exploring, and remember that the digital highway is full of exciting possibilities!

Demystifying IP Addresses with is.ipv4 and is.not_ipv4 from 'thiis': Your Friendly Guide to IP Validation

Ivan Karbashevskyi — Tue, 28 Nov 2023 10:23:25 +0000

Welcome, fellow coders, to a fascinating exploration of IP addresses in JavaScript! Today, we'll unravel the secrets of validating IPv4 addresses using the is.ipv4 method and its trusty companion, is.not_ipv4. Get ready for a journey into the world of networking and precision in your JavaScript applications.

Understanding IPv4 Addresses

Before we dive into the tools at hand, let's take a moment to demystify IPv4 addresses. These addresses are the numerical labels assigned to devices participating in a computer network that uses the Internet Protocol for communication. An IPv4 address consists of four numbers separated by periods, each ranging from 0 to 255.

Meet `is.ipv4` - Your IPv4 Validator

Documentation link

Imagine you're working on a project that involves handling IP addresses, and you want to ensure that a given value is a valid IPv4 address. Enter the is.ipv4 method, your trusty IPv4 validator. Let's see it in action:

import { is } from 'thiis'; // Import the "is" object from the "thiis" package

const ipAddress = '192.168.0.1';
const result = is.ipv4(ipAddress);

console.log(result); // true

In this example, we import the "is" object from the "thiis" package and use the is.ipv4 method to confirm that ipAddress is indeed a valid IPv4 address. As expected, it returns true because the value is a valid IPv4 address.

The Grand Tour of Examples

Now, let's embark on a grand tour featuring six captivating examples that showcase the versatility of is.ipv4 and its companion, is.not_ipv4. Buckle up for a mix of practical scenarios!

1. Basic IPv4 Validation

The primary role of is.ipv4 is to validate IPv4 addresses. Use it to check if an address is in the correct format:

import { is } from 'thiis';

const ipAddress = '192.168.0.1';

if (is.ipv4(ipAddress)) {
  // Proceed confidently with the valid IPv4 address.
} else {
  // Handle the case where the address is not valid.
}

2. Guarding Against Non-IPv4 Values

On the flip side, is.not_ipv4 acts as your guardian against non-IPv4 values. Ensure that a value is not an IPv4 address before proceeding:

import { is } from 'thiis';

const questionableValue = someFunctionThatMayReturnNonIPv4Value();

if (is.not_ipv4(questionableValue)) {
  // Your guardian prevents non-IPv4 mishaps!
} else {
  // Time to explore other possibilities.
}

3. Form Validation with `is.ipv4`

Imagine you're developing a form that requires an IPv4 address. Use is.ipv4 to validate user input:

import { is } from 'thiis';

function validateIpAddress(input) {
  if (is.ipv4(input)) {
    return 'IPv4 address validated successfully!';
  } else {
    return 'Please provide a valid IPv4 address.';
  }
}

4. Handling IP Address Arrays

Arrays are common in programming, and IP addresses can be part of them. Use every() with is.ipv4 to ensure that all elements are valid IPv4 addresses:

import { is } from 'thiis';

const ipAddresses = ['192.168.0.1', '10.0.0.2', '256.256.256.256'];

const allValid = ipAddresses.every(is.ipv4); // false

console.log(allValid);

In this example, allValid checks if all elements in ipAddresses are valid IPv4 addresses. In this case, it returns false because '256.256.256.256' is not a valid IPv4 address.

5. Stream of IPv4 Addresses

Let's spice things up with RxJS and stream$. Using filter and is.ipv4, we can ensure that the stream processes only valid IPv4 addresses:

import { is } from 'thiis';
import { from } from 'rxjs';
import { filter } from 'rxjs/operators';

const ipStream$ = from(['192.168.0.1', 'not an IP', '10.0.0.2', 'invalid.address']);

ipStream$
  .pipe(
    filter(is.ipv4)
  )
  .subscribe(validIp => {
    console.log(validIp); // Only valid IPv4 addresses will be part of the stream's story.
  });

In this example, the filter(is.ipv4) ensures that only valid IPv4 addresses get processed by the stream.

6. Mixing IPv4 and Non-IPv4 in an Array

Arrays may contain a mix of IPv4 and non-IPv4 values. Use some() with is.not_ipv4 to check if at least one element is not a valid IPv4 address:

import { is } from 'thiis';

const mixedAddresses = ['192.168.0.1', 'not an IP', '10.0.0.2'];

const hasNonIPv4 = mixedAddresses.some(is.not_ipv4); // true

console.log(hasNonIPv4);

Here, hasNonIPv4 checks if at least one element in mixedAddresses is not a valid IPv4 address, and it returns true.

7. Additional examples

is.ipv4('192.168.1.1'); // true
is.ipv4('255.255.255.0'); // true
is.ipv4('10.0.0.1'); // true
is.ipv4('172.16.0.1'); // true

is.ipv4(`a`); // false
is.ipv4("r"); // false
is.ipv4('t'); // false
is.ipv4(`3`); // false
is.ipv4(`1`); // false
is.ipv4(`2`); // false
is.ipv4('hello'); // false
is.ipv4('hello123'); // false
is.ipv4('helloWorld'); // false
is.ipv4('a1B2c3d4e5f6g'); // false
is.ipv4('a1B2c3d4e5f6'); // false
is.ipv4('inCamelCase'); // false
is.ipv4('undefined'); // false
is.ipv4('null'); // false
is.ipv4(BigInt(1)) // false
is.ipv4(0) // false
is.ipv4(1) // false
is.ipv4(-1) // false
is.ipv4(Symbol()) // false
is.ipv4(null) // false
is.ipv4(true) // false
is.ipv4([]) // false
is.ipv4(false) // false
is.ipv4("") // false
is.ipv4('') // false
is.ipv4(``) // false
is.ipv4({}) // false
is.ipv4(undefined) // false
is.ipv4(Function) // false
is.ipv4(() => {}) // false
is.ipv4(BigInt) // false
is.ipv4(Symbol) // false
is.ipv4(NaN) // false
is.ipv4(Infinity) // false
is.ipv4(-Infinity) // false
is.ipv4(Number.POSITIVE_INFINITY) // false
is.ipv4(Number.NEGATIVE_INFINITY) // false
// And all other known types will return false

is.not_ipv4('192.168.1.1'); // false
is.not_ipv4('255.255.255.0'); // false
is.not_ipv4('10.0.0.1'); // false
is.not_ipv4('172.16.0.1'); // false

is.not_ipv4(`a`); // true
is.not_ipv4("r"); // true
is.not_ipv4('t'); // true
is.not_ipv4(`3`); // true
is.not_ipv4(`1`); // true
is.not_ipv4(`2`); // true
is.not_ipv4('hello'); // true
is.not_ipv4('hello123'); // true
is.not_ipv4('helloWorld'); // true
is.not_ipv4('a1B2c3d4e5f6g'); // true
is.not_ipv4('a1B2c3d4e5f6'); // true
is.not_ipv4('inCamelCase'); // true
is.not_ipv4('undefined'); // true
is.not_ipv4('null'); // true
is.not_ipv4(BigInt(1)) // true
is.not_ipv4(0) // true
is.not_ipv4(1) // true
is.not_ipv4(-1) // true
is.not_ipv4(Symbol()) // true
is.not_ipv4(null) // true
is.not_ipv4(true) // true
is.not_ipv4([]) // true
is.not_ipv4(false) // true
is.not_ipv4("") // true
is.not_ipv4('') // true
is.not_ipv4(``) // true
is.not_ipv4({}) // true
is.not_ipv4(undefined) // true
is.not_ipv4(Function) // true
is.not_ipv4(() => {}) // true
is.not_ipv4(BigInt) // true
is.not_ipv4(Symbol) // true
is.not_ipv4(NaN) // true
is.not_ipv4(Infinity) // true
is.not_ipv4(-Infinity) // true
is.not_ipv4(Number.POSITIVE_INFINITY) // true
is.not_ipv4(Number.NEGATIVE_INFINITY) // true
// And all other known types will return true

The Adventure's Conclusion

The is.ipv4 and is.not_ipv4 methods from the 'thiis' package are your companions on a thrilling journey into the realm of IPv4 validation in JavaScript. They bring precision to your networking tasks and ensure your code interacts with IPv4 addresses exactly as intended. By adding the 'thi

is' package to your JavaScript toolkit and exploring its documentation for more tips and examples, you can navigate the networking landscape with confidence and a dash of fun.

So, go forth and code with the assurance that your JavaScript applications are equipped to handle IPv4 addresses seamlessly!

Discover the Charm of is.char and is.not_char in JavaScript with 'thiis'

Ivan Karbashevskyi — Mon, 27 Nov 2023 08:40:26 +0000

JavaScript, with its dynamic nature, often involves dealing with various data types. When it comes to characters, ensuring that you're working with them correctly is crucial. That's where the is.char method and its counterpart, is.not_char from the 'thiis' package, come into play. In this article, we'll embark on a charming journey, exploring these methods and their utility in different scenarios.

Unveiling the Magic of Characters in JavaScript

Before we embark on our journey, let's take a moment to appreciate characters in JavaScript. A character is a single unit of text, and it can be a letter, number, or a special symbol. Ensuring that a value is indeed a character is essential for handling strings with precision.

Meet `is.char` - Your Character Connoisseur

Documentation link

Imagine you're on a quest to determine whether a value is a character. The is.char method is like your character connoisseur, helping you confirm if a value is indeed a character. Let's witness its charm:

import { is } from 'thiis'; // Import the "is" object from the "thiis" package

const myCharacter = 'a';
const result = is.char(myCharacter);

console.log(result); // true

In this example, we import the "is" object from the "thiis" package and use the is.char method to confirm that myCharacter is indeed a character. As expected, it returns true because the value is indeed a character.

The Charmed Examples

Now, let's explore six examples that showcase the versatility of is.char and its companion is.not_char. We'll cover a range of scenarios, including a delightful encounter with stream$ and a charming exploration of an array.

1. Checking a Single Character

The primary purpose of is.char is to confirm if a value is a single character. This is useful when validating user input or working with individual characters in a string:

import { is } from 'thiis';

const userInput = 'b';

if (is.char(userInput)) {
  // It's a charmer! Proceed with delight.
} else {
  // Handle the case where it's not a character gracefully.
}

2. Guarding Against Non-Characters

On the flip side, is.not_char is your guardian against non-character values. It ensures that a value is not a character before proceeding:

import { is } from 'thiis';

const potentialNonChar = 123;

if (is.not_char(potentialNonChar)) {
  // Your guardian saves the day! Proceed with joy.
} else {
  // Handle the scenario where it's unexpectedly a character.
}

3. Charmed Validation Function

Let's create a charming validation function that ensures a string consists of only characters:

import { is } from 'thiis';

function validateString(inputString) {
  if (inputString.split('').every(is.char)) {
    return 'String validated with charm!';
  } else {
    return 'Oops, non-characters detected!';
  }
}

4. Charming Array Exploration

Arrays often contain a mix of data types. Use is.char to ensure that only characters make it into your array:

import { is } from 'thiis';

const charArray = ['a', 'b', 'c'];
const mixedArray = ['x', 123, 'y', true];

const allAreChars = charArray.every(is.char); // true
const someAreChars = mixedArray.some(is.char); // true

console.log(allAreChars);
console.log(someAreChars);

5. Charmed Stream of Characters

Let's explore a scenario involving stream$ from RxJS. Using filter and is.char, we can ensure that the stream processes only character values:

import { is } from 'thiis';
import { from } from 'rxjs';
import { filter } from 'rxjs/operators';

const charStream$ = from(['a', 123, 'b', true]);

charStream$
  .pipe(
    filter(is.char)
  )
  .subscribe(char => {
    console.log(char); // Only character values will be part of the charmed stream.
  });

6. Checking Charming User Input

When interacting with user input, especially from forms, use is.char to ensure that the entered value is a charming single character:

import { is } from 'thiis';

const userInput = document.getElementById('charInput').value;

if (is.char(userInput)) {
  // The user's input is a delightful single character!
} else {
  // Kindly guide the user to enter a valid character.
}

The Charmed Conclusion

The is.char and is.not_char methods from the 'thiis' package add a touch of charm to your JavaScript journey. They ensure that your code interacts with characters exactly as intended, bringing clarity and precision to your character-related tasks. By incorporating the 'thiis' package into your JavaScript toolkit and exploring its documentation for more tips and examples, you can navigate the JavaScript landscape with a smile and a sprinkle of charm.

So, keep coding, and may your JavaScript endeavors be filled with characters that charm and delight!

Unraveling the Mystery of is.camelCase with 'thiis': Your Guide to JavaScript Naming Conventions

Ivan Karbashevskyi — Sun, 26 Nov 2023 19:02:43 +0000

JavaScript is a language of endless possibilities, and one aspect that adds charm to your code is the art of naming variables. One popular convention is camelCase, where words are joined together, starting with a lowercase letter and subsequent words capitalized. But how can you ensure that a string follows this elegant camelCase pattern? Enter the is.camelCase method from the 'thiis' package! In this article, we'll embark on a delightful journey to understand this method and its partner, is.not_camelCase, through six friendly examples.

Understanding the Elegance of CamelCase in JavaScript

Before we dive into the world of is.camelCase, let's take a moment to appreciate the elegance of camelCase in JavaScript. It's not just a naming convention; it's a style that makes your code more readable and aesthetically pleasing.

Meet `is.camelCase` - Your CamelCase Validator

Documentation link

Imagine you're navigating through your code, and you want to make sure that a string adheres to the camelCase convention. That's where the is.camelCase method comes to your rescue:

import { is } from 'thiis'; // Import the "is" object from the "thiis" package

const myString = 'helloWorld';
const result = is.camelCase(myString);

console.log(result); // true

In this example, we import the "is" object from the "thiis" package and use the is.camelCase method to confirm that myString follows the camelCase convention. As expected, it returns true.

The Journey of Examples

Now, let's embark on a journey through various examples that showcase the magic of is.camelCase and its companion, is.not_camelCase.

1. Checking Variable Names

The primary use of is.camelCase is to check if a variable name follows the camelCase convention. This ensures your codebase maintains a consistent and clean style:

import { is } from 'thiis';

const variableName = 'myAwesomeVariable';
const isCamelCase = is.camelCase(variableName);

if (isCamelCase) {
  // Your variable name is a piece of camelCase beauty!
} else {
  // Consider giving it a camelCase makeover.
}

2. Guarding Function Names

Function names are another playground for camelCase. Use is.not_camelCase to ensure that a function name doesn't break the camelCase pattern:

import { is } from 'thiis';

const functionName = 'myFunctionName';
const isValidFunctionName = is.not_camelCase(functionName);

if (isValidFunctionName) {
  // Your function name is a camelCase superstar!
} else {
  // Think about embracing the camelCase style.
}

3. Validating User Input

Let's say you're receiving input from users, and you want to validate that their chosen username follows the camelCase convention:

import { is } from 'thiis';

function validateUsername(username) {
  if (is.camelCase(username)) {
    return 'Username validated successfully!';
  } else {
    return 'Please choose a username in camelCase.';
  }
}

4. Conditional Styling in CSS

Even in the world of stylesheets, camelCase plays a role. Use is.camelCase to ensure that your CSS class names adhere to the camelCase pattern:

import { is } from 'thiis';

const className = 'myStyledComponent';
const isCamelCased = is.camelCase(className);

if (isCamelCased) {
  // Your styling is following the camelCase tradition!
} else {
  // Time for a little CSS camelCase makeover.
}

5. Stream of Style with `is.camelCase`

Let's dive into a scenario involving stream$ from RxJS. Using filter and is.camelCase, we can ensure that the stream processes only strings that follow the camelCase convention:

import { is } from 'thiis';
import { from } from 'rxjs';
import { filter } from 'rxjs/operators';

const stream$ = from(['camelCaseString', 'NotCamelCase', 'anotherCamelCase']);

stream$
  .pipe(
    filter(is.camelCase)
  )
  .subscribe(value => {
    console.log(value); // Only camelCase strings will be part of the stream's story.
  });

In this example, the filter(is.camelCase) ensures that only camelCase strings get processed by the stream.

6. Array Exploration with `is.not_camelCase`

Arrays are yet another realm for camelCase exploration. You can use every() to confirm that all elements are not camelCase and some() to check if at least one is:

import { is } from 'thiis';

const notCamelCaseArray = ['nonCamelCase', 'NONCAMELCASE', 'AnotherString'];
const mixedArray = ['camelCaseString', 'NotCamelCase', 'AnotherString'];

const allElementsNotCamelCase = notCamelCaseArray.every(is.not_camelCase); // true
const someElementsNotCamelCase = mixedArray.some(is.not_camelCase); // true

console.log(allElementsNotCamelCase);
console.log(someElementsNotCamelCase);

Here, allElementsNotCamelCase checks if all elements in notCamelCaseArray are not camelCase, and someElementsNotCamelCase checks if at least one element in mixedArray is not camelCase.

The Adventure Continues

The is.camelCase and is.not_camelCase methods from the 'thiis' package are your reliable guides on your JavaScript adventure. They make checking naming conventions a breeze, ensuring your code follows the camelCase pattern. By adding the 'thiis' package to your JavaScript toolkit and exploring

its documentation for more tips and examples, you can navigate the world of JavaScript with style and a touch of fun.

So, keep coding with style, and remember that the journey of JavaScript is full of exciting discoveries!

Unveiling the Magic of Promises with `is.promise` and `is.not_promise` from 'thiis'

Ivan Karbashevskyi — Sat, 25 Nov 2023 13:38:03 +0000

JavaScript is an enchanting realm filled with promises, and not just the kind you make to your code but the special kind that handles asynchronous operations. In this magical journey, we'll unravel the secrets of promises using the is.promise and is.not_promise methods from the 'thiis' package. Get ready to embark on an adventure into the world of JavaScript promises!

Embracing the World of Promises

Before we dive into the magic, let's understand what promises are in JavaScript. Promises are a way to handle asynchronous operations, providing a cleaner alternative to callbacks. They represent a value that may be available now, or in the future, or never. Asynchronous tasks like fetching data from an API or reading a file often involve promises.

Meet `is.promise` - Your Promise Whisperer

Documentation link

Imagine you're in a world full of promises, and you need a guide to help you distinguish them. That's where the is.promise method comes in. It's like a magical whisperer that tells you whether a value is indeed a promise. Let's witness its magic:

import { is } from 'thiis'; // Import the "is" object from the "thiis" package

const myPromise = fetch('https://api.example.com/data');
const result = is.promise(myPromise);

console.log(result); // true

In this example, we import the "is" object from the "thiis" package and use the is.promise method to confirm that myPromise is indeed a promise. As expected, it returns true because the value is indeed a promise.

The Magic Unveiled: Examples Galore!

Now, let's explore a series of enchanting examples that showcase the versatility of is.promise and its companion, is.not_promise. We'll encounter scenarios involving promises in various shapes and sizes.

1. Chasing Async Dreams with `is.promise`

The primary role of is.promise is to identify promises. It's your compass in the realm of asynchronous operations:

import { is } from 'thiis';

const asyncOperation = someAsyncFunction();

if (is.promise(asyncOperation)) {
  // Embrace the asynchronous magic!
} else {
  // Continue with other synchronous tasks.
}

2. Guardian of Non-Promises - `is.not_promise`

Conversely, is.not_promise serves as your guardian against non-promises. It ensures that a value isn't a promise before proceeding:

import { is } from 'thiis';

const importantValue = someFunctionThatShouldNotReturnAPromise();

if (is.not_promise(importantValue)) {
  // Your guardian ensures a smooth path.
} else {
  // Time to explore other possibilities.
}

3. Promising User Interactions

Promises often play a role in user interactions, especially when dealing with asynchronous actions. Validate promises with is.promise:

import { is } from 'thiis';

function performAsyncTask() {
  return new Promise(resolve => {
    // Simulating an asynchronous task
    setTimeout(() => {
      resolve('Task completed!');
    }, 1000);
  });
}

const userAction = getUserInput();

if (is.promise(userAction)) {
  // User is ready for asynchronous adventures!
} else {
  // Handle other types of user actions.
}

4. Magical Streams with `is.promise`

In the enchanting world of streams, you might encounter promises. Use filter and is.promise to ensure that only promise values are part of your stream:

import { is } from 'thiis';
import { from } from 'rxjs';
import { filter } from 'rxjs/operators';

const stream$ = from([Promise.resolve('Magical Promise'), 'not a promise', 42]);

stream$
  .pipe(
    filter(is.promise)
  )
  .subscribe(value => {
    console.log(value); // Only the magical promise will join the stream!
  });

Here, the filter(is.promise) ensures that only promise values are part of the stream.

5. Array Adventures with `is.not_promise`

Arrays can also be magical, but sometimes you want to ensure they don't contain promises. Use some and is.not_promise for this magical check:

import { is } from 'thiis';

const nonPromiseArray = [1, 'not a promise', true];
const promiseArray = [Promise.resolve('Magical Promise'), 'not magical', 42];

const hasNoPromises = nonPromiseArray.some(is.not_promise); // true
const hasPromises = promiseArray.some(is.not_promise); // false

console.log(hasNoPromises);
console.log(hasPromises);

Here, hasNoPromises checks if there are no promises in nonPromiseArray, and hasPromises checks if there are promises in promiseArray.

6. Promise or Not? Let's Check!

Sometimes you just want to know if something is a promise or not. Use is.promise for a straightforward check:

import { is } from 'thiis';

const mysteriousThing = getSomeMysteriousValue();

if (is.promise(mysteriousThing)) {
  // It's a promise! The mystery unfolds.
} else {
  // The mystery remains unsolved.
}

The Enchanting Conclusion

The is.promise and is.not_promise methods from the 'thiis' package are your magical companions in the world of JavaScript promises. They make handling asynchronous operations playful and precise, ensuring your code interacts with promises exactly as intended. By adding the 'thiis' package to your JavaScript toolkit and exploring its documentation for more tips and examples, you can weave magical spells in your asynchronous adventures.

So, continue coding, and may your promises always resolve!

Navigating JavaScript with Ease: Unveiling `is.null` and `is.not_null` from 'thiis'

Ivan Karbashevskyi — Fri, 24 Nov 2023 08:16:40 +0000

JavaScript, the realm of endless possibilities, sometimes requires us to decipher the mysteries of null values. Fear not, for the 'thiis' package brings two trusty companions to your aid: is.null and is.not_null. In this delightful journey, we'll explore these tools, uncovering their magic and weaving them into the fabric of everyday JavaScript adventures.

Embracing the Null Quest

Before we embark on our quest, let's grasp the concept of null in JavaScript. Null is a special value that represents the absence of a value or a variable that has been declared but not assigned any value. Identifying and handling null is crucial for building robust and error-free code.

Meet `is.null` - Your Null Navigator

Documentation link

Imagine you're on a grand quest to find null values in your code. The is.null method acts as your trustworthy navigator, ensuring that a value is indeed null. Let's witness it in action:

import { is } from 'thiis'; // Import the "is" object from the "thiis" package

const myValue = null;
const result = is.null(myValue);

console.log(result); // true

In this example, we import the "is" object from the "thiis" package and use the is.null method to confirm that myValue is indeed null. As expected, it returns true because the value is indeed null.

A Symphony of Examples

Now, let's compose a symphony of examples that showcase the versatility of is.null and its companion, is.not_null. We'll explore six unique scenarios, dancing through various landscapes of JavaScript.

1. Embracing Null Values

The primary role of is.null is to identify null values. Use it to gracefully handle situations where a value might be null:

import { is } from 'thiis';

const potentiallyNullValue = someFunctionThatMayReturnNull();

if (is.null(potentiallyNullValue)) {
  // Handle the null scenario gracefully.
} else {
  // Continue with confidence.
}

2. Guarding Against Null

Conversely, is.not_null is your guardian against null values. Ensure a value isn't null before proceeding:

import { is } from 'thiis';

const importantValue = someFunctionThatShouldNotBeNull();

if (is.not_null(importantValue)) {
  // Your guardian prevents null mishaps!
} else {
  // Time to explore other possibilities.
}

3. Validating Inputs with `is.null`

When working with user inputs, ensuring they are not null is essential. Use is.null to validate and prompt users to provide valid inputs:

import { is } from 'thiis';

function validateUserInput(input) {
  if (is.null(input)) {
    return 'Please provide a valid input.';
  } else {
    return 'Input validated successfully!';
  }
}

4. Robust Conditionals with `is.not_null`

Conditionals are at the heart of programming. Ensure a value is not null before executing specific actions with is.not_null:

import { is } from 'thiis';

const userChoice = getUserInput();

if (is.not_null(userChoice)) {
  // Execute actions for valid choices.
} else {
  // Handle other scenarios with grace.
}

5. Stream of Clarity with `is.null`

Let's embark on a stream adventure with RxJS. Using filter and is.null, ensure that the stream processes only null values:

import { is } from 'thiis';
import { from } from 'rxjs';
import { filter } from 'rxjs/operators';

const stream$ = from([null, 'not null', undefined, 'another value', null]);

stream$
  .pipe(
    filter(is.null)
  )
  .subscribe(value => {
    console.log(value); // Only null values will be part of the stream's story.
  });

In this example, the filter(is.null) ensures that only null values get processed by the stream.

6. Array Exploration with `is.not_null`

Arrays are another playground for is.not_null. Use every() to confirm that all elements are not null and some() to check if at least one isn't:

import { is } from 'thiis';

const notNullArray = [1, 'not null', true];
const mixedArray = [null, 'not null', 0, undefined];

const allElementsNotNull = notNullArray.every(is.not_null); // true
const someElementsNotNull = mixedArray.some(is.not_null); // true

console.log(allElementsNotNull);
console.log(someElementsNotNull);

Here, allElementsNotNull checks if all elements in notNullArray are not null, and someElementsNotNull checks if at least one element in mixedArray is not null.

The Adventure Continues

The is.null and is.not_null methods from the 'thiis' package are your reliable companions on your JavaScript adventure. They make null handling playful and precise, ensuring your code interacts with null values exactly as intended. By adding the 'thiis' package to your JavaScript toolkit and exploring its documentation for more tips and examples, you can navigate the JavaScript landscape with confidence and a touch of fun.

So, keep coding, and remember that JavaScript is a grand adventure waiting to unfold! And, as always, a big thank you to ChatGPT for making this article an enjoyable journey into the world of JavaScript null values.

Navigating the Symbolic World with is.symbol and is.not_symbol from 'thiis': Unraveling JavaScript Magic

Ivan Karbashevskyi — Thu, 23 Nov 2023 11:07:33 +0000

JavaScript, like magic, is full of enchanting elements, and symbols are one such mystical feature. Symbols are unique and can be both fascinating and tricky to work with. Fear not! With the magical tools is.symbol and is.not_symbol from the 'thiis' package, you can confidently navigate the symbolic world of JavaScript. In this article, we'll explore these tools through friendly examples, revealing the magic behind symbols.

The Magic of Symbols in JavaScript

Before we embark on our magical journey, let's understand what symbols are. In JavaScript, symbols are a primitive data type, and each symbol created is unique. They are often used as keys for object properties, adding a touch of magic to your code.

Meet `is.symbol` - Your Symbolic Guide

Documentation link

Picture yourself in a realm where symbols abound, and you want to identify if a value is indeed a symbol. The is.symbol method acts as your magical guide, confirming whether a value is a symbol or not. Let the magic unfold:

import { is } from 'thiis'; // Import the "is" object from the "thiis" package

const magicalSymbol = Symbol('magic'); // Creating a symbolic value
const result = is.symbol(magicalSymbol);

console.log(result); // true

In this example, we import the "is" object from the "thiis" package and use the is.symbol method to confirm that magicalSymbol is indeed a symbol. As expected, it returns true, unveiling the magic of symbols.

The Journey of Examples

Now, let's embark on a magical journey with six enchanting examples, including one with stream$ and another involving an array.

1. Discovering the Symbolic Secrets

The primary role of is.symbol is to unveil the symbolic nature of a value. It helps you uncover the magic when working with symbols:

import { is } from 'thiis';

const mysteriousSymbol = someFunctionThatMayReturnSymbol();

if (is.symbol(mysteriousSymbol)) {
  // You've discovered the symbolic secret!
} else {
  // Continue your journey with anticipation.
}

2. Guarding Against Non-Symbols

Conversely, is.not_symbol serves as a guardian against non-symbolic values. It ensures that a value isn't a symbol before proceeding, protecting your magical realm:

import { is } from 'thiis';

const importantValue = someFunctionThatShouldNotBeSymbol();

if (is.not_symbol(importantValue)) {
  // Your guardian prevents non-symbolic mishaps!
} else {
  // Time to explore other magical possibilities.
}

3. Creating Magical Constants

Symbols are often used to create unique constants. Use is.symbol to validate that a constant is indeed a magical symbol:

import { is } from 'thiis';

const MAGIC_CONSTANT = Symbol('magic_constant');

if (is.symbol(MAGIC_CONSTANT)) {
  // Embrace the magic of your constant!
} else {
  // Handle the non-symbolic scenario gracefully.
}

4. Magical Stream Filtering

Let's dive into a magical stream scenario with RxJS. Using filter and is.symbol, we can ensure that the stream processes only values that are symbols:

import { is } from 'thiis';
import { from } from 'rxjs';
import { filter } from 'rxjs/operators';

const magicalStream$ = from([42, 'not a symbol', Symbol('magic'), { obj: 'not a symbol' }]);

magicalStream$
  .pipe(
    filter(is.symbol)
  )
  .subscribe(value => {
    console.log(value); // Only magical symbols will be part of the stream's tale.
  });

In this example, the filter(is.symbol) ensures that only symbolic values get processed by the magical stream.

5. Enchanting Array Exploration

Arrays are another dimension for is.not_symbol. You can use every() to confirm that all elements are not symbols and some() to check if at least one isn't:

import { is } from 'thiis';

const notSymbolArray = [1, 'not a symbol', true];
const magicalArray = [Symbol('magic'), 'not a symbol', 42];

const allElementsNotSymbol = notSymbolArray.every(is.not_symbol); // true
const someElementsNotSymbol = magicalArray.some(is.not_symbol); // true

console.log(allElementsNotSymbol);
console.log(someElementsNotSymbol);

Here, allElementsNotSymbol checks if all elements in notSymbolArray are not symbols, and someElementsNotSymbol checks if at least one element in magicalArray is not a symbol.

6. Magical Object Keys

Symbols are often used as unique keys for object properties. Use is.symbol to ensure that a property key is truly magical:

import { is } from 'thiis';

const magicalKey = Symbol('magic_key');
const obj = {
  [magicalKey]: 'Abracadabra!',
  ordinaryKey: 'Just a key',
};

if (is.symbol(Object.getOwnPropertySymbols(obj)[0])) {
  console.log(obj[magicalKey]); // Unleash the magic of the object property!
} else {
  // Handle the non-symbolic property with grace.
}

The Magical Adventure Continues

The is.symbol and is.not_symbol methods from the 'thiis' package are your magical companions on your JavaScript journey. They make working with symbols a delightful experience, ensuring your code interacts with these enchanting values precisely as intended. By adding the 'thiis' package to your JavaScript toolkit and exploring its documentation for more tips and examples, you can navigate the symbolic landscape with confidence and a dash of magic.

So, keep coding, and may your JavaScript be filled with enchantment! A special thanks to ChatGPT for making this article a magical experience.

Unveiling the Magic of is.undefined and is.not_undefined with 'thiis': Navigating the Undefined Realms in JavaScript

Ivan Karbashevskyi — Wed, 22 Nov 2023 11:33:48 +0000

JavaScript is a realm of endless possibilities, and one of its intriguing mysteries lies in the concept of undefined. Handling situations where values are undefined is a common challenge for developers. Fear not, for the is.undefined and is.not_undefined methods from the 'thiis' package are here to guide you through the undefined realms of JavaScript. In this article, let's embark on an adventure to unravel the magic of these tools with fun and practical examples.

The Enigmatic World of `undefined` in JavaScript

Before we dive into our exploration, let's demystify what undefined means in JavaScript. It signifies the absence of a value or the lack of an assigned value to a variable. Recognizing and handling undefined is crucial for writing robust and bug-free code.

Meet `is.undefined` - Your Undefined Navigator

Documentation link

Imagine you're on a quest to navigate the undefined territories in your code. The is.undefined method acts as your seasoned navigator, ensuring that a value is indeed undefined. Let's witness its magic:

import { is } from 'thiis'; // Import the "is" object from the "thiis" package

let myUndefinedValue;
const result = is.undefined(myUndefinedValue);

console.log(result); // true

In this example, we import the "is" object from the "thiis" package and use the is.undefined method to confirm that myUndefinedValue is indeed undefined. As expected, it returns true because the value is, in fact, undefined.

The Expedition of Examples

Now, let's embark on an exciting journey through a variety of examples that showcase the versatility of is.undefined and its trusty companion, is.not_undefined.

1. Detecting Undefined Values

The primary role of is.undefined is to identify when a value is undefined. It comes in handy when dealing with situations where a variable might not be assigned a value:

import { is } from 'thiis';

let potentialUndefined;
if (is.undefined(potentialUndefined)) {
  // Handle the situation gracefully.
} else {
  // Continue with confidence.
}

2. Guarding Against Undefined Values

Conversely, is.not_undefined is your guardian against undefined values. It ensures that a value is not undefined before proceeding with operations:

import { is } from 'thiis';

const importantValue = someFunctionThatShouldNotReturnUndefined();

if (is.not_undefined(importantValue)) {
  // Proceed with confidence.
} else {
  // Handle undefined scenarios.
}

3. Validating Function Parameters

When defining functions, it's essential to validate parameters to avoid unexpected undefined values:

import { is } from 'thiis';

function greetUser(name) {
  if (is.undefined(name)) {
    return 'Hello, mysterious stranger!';
  } else {
    return `Hello, ${name}!`;
  }
}

4. Ensuring Object Properties Exist

When working with objects, ensure that a property exists before trying to access it:

import { is } from 'thiis';

const user = {
  name: 'John',
  age: 25,
  // No address property
};

if (is.not_undefined(user.address)) {
  // Safely access and use the address property.
} else {
  // Handle the absence of the address property.
}

5. Navigating Streams with `is.undefined`

Let's explore a scenario involving stream$ from RxJS. Using filter and is.undefined, we can ensure that the stream processes only values that are undefined:

import { is } from 'thiis';
import { from } from 'rxjs';
import { filter } from 'rxjs/operators';

const stream$ = from([undefined, 'not undefined', null, 0, 'a value']);

stream$
  .pipe(
    filter(is.undefined)
  )
  .subscribe(value => {
    console.log(value); // Only undefined values will be part of the stream's story.
  });

In this example, the filter(is.undefined) ensures that only undefined values get processed by the stream.

6. Array Exploration with `is.not_undefined`

Arrays offer another playground for is.not_undefined. You can use every() to confirm that all elements are not undefined and some() to check if at least one isn't:

import { is } from 'thiis';

const notUndefinedArray = [1, 'not undefined', true];
const mixedArray = [undefined, 'not undefined', null, undefined];

const allElementsNotUndefined = notUndefinedArray.every(is.not_undefined); // true
const someElementsNotUndefined = mixedArray.some(is.not_undefined); // true

console.log(allElementsNotUndefined);
console.log(someElementsNotUndefined);

Here, allElementsNotUndefined checks if all elements in notUndefinedArray are not undefined, and someElementsNotUndefined checks if at least one element in mixedArray is not undefined.

The Adventure Continues

The is.undefined and is.not_undefined methods from the 'thiis' package are your reliable guides through the undefined realms of JavaScript. They make handling undefined values playful and precise, ensuring your code navigates the undefined territories with confidence. By adding the 'thiis' package to your JavaScript toolkit and exploring its documentation for more tips and examples, you can boldly venture into the unknowns of JavaScript coding.

So, keep coding, and remember that the undefined realms are full of surprises!

Navigating the JavaScript Frontier with is.primitive and is.not_primitive from 'thiis'

Ivan Karbashevskyi — Tue, 21 Nov 2023 12:09:04 +0000

JavaScript, the land of endless possibilities, often involves working with different data types. Sometimes, you just need to know if you're dealing with the basic building blocks—primitive values. Enter the is.primitive method and its trusty companion, is.not_primitive, from the 'thiis' package. In this friendly exploration, we'll embark on a journey through JavaScript's diverse landscape and learn how these methods can simplify your coding adventures.

Understanding the Primitives of JavaScript

Before we dive into the magical world of is.primitive, let's quickly review what primitive values are in JavaScript. Primitives are the simplest, indivisible building blocks of the language. They include numbers, strings, booleans, null, undefined, and symbols. Recognizing these is crucial for understanding how values behave in your code.

Meet `is.primitive` - Your Guide to Simplicity

Documentation link

Imagine you're wandering through a vast JavaScript forest, and you come across a mysterious value. Is it a primitive, or something more complex? The is.primitive method acts as your guide, helping you determine if a value is indeed a primitive. Let's see it in action:

import { is } from 'thiis'; // Import the "is" object from the "thiis" package

const myValue = 42;
const result = is.primitive(myValue);

console.log(result); // true

In this example, we import the "is" object from the "thiis" package and use the is.primitive method to confirm that myValue is indeed a primitive value. As expected, it returns true because the value is a number, a primitive in JavaScript.

The Journey of Examples

Now, let's embark on a delightful journey through six unique scenarios, showcasing the simplicity and power of is.primitive and its companion, is.not_primitive. We'll explore a variety of situations, from user input to streams and arrays.

1. Validating User Input as Primitive

When users interact with your application, it's essential to validate their input. is.primitive can help ensure that the input is a simple, primitive value:

import { is } from 'thiis';

function validateUserInput(input) {
  if (is.primitive(input)) {
    return 'Input validated as a primitive value!';
  } else {
    return 'Please provide a simple, primitive value.';
  }
}

2. Guarding Against Non-Primitives

Conversely, is.not_primitive is your guardian against non-primitive values. It ensures that the value is not something more complex:

import { is } from 'thiis';

const complexObject = { data: 'not primitive' };

if (is.not_primitive(complexObject)) {
  // Handle the scenario where the value is not a primitive.
} else {
  // Continue with the simplicity of primitives.
}

3. Navigating a Stream of Values

Let's dive into the world of streams using RxJS. You can use filter and is.primitive to ensure that your stream processes only primitive values:

import { is } from 'thiis';
import { from } from 'rxjs';
import { filter } from 'rxjs/operators';

const stream$ = from([42, 'a string', { object: 'not primitive' }, true, null]);

stream$
  .pipe(
    filter(is.primitive)
  )
  .subscribe(value => {
    console.log(value); // Only primitive values will continue down the stream.
  });

In this example, the filter(is.primitive) ensures that only primitive values are processed by the stream.

4. Array Exploration with `is.not_primitive`

Arrays are a common playground for different data types. Use is.not_primitive with some() to check if at least one element is not a primitive:

import { is } from 'thiis';

const mixedArray = [42, 'string', { object: 'not primitive' }, true, null];

const hasNonPrimitive = mixedArray.some(is.not_primitive); // true

console.log(hasNonPrimitive);

Here, hasNonPrimitive checks if at least one element in mixedArray is not a primitive value.

5. Simple Math with `is.primitive`

Math operations often involve primitive values. Use is.primitive to ensure that a value is suitable for basic arithmetic:

import { is } from 'thiis';

const myNumber = 42;

if (is.primitive(myNumber)) {
  const result = myNumber * 2;
  console.log(result); // 84
} else {
  console.log('Not a valid primitive for arithmetic operations.');
}

6. Checking for `undefined`

is.not_primitive is handy when checking for undefined, ensuring your code handles cases where a value is not defined:

import { is } from 'thiis';

let myVariable;

if (is.not_primitive(myVariable)) {
  // Handle the scenario where the variable is defined.
} else {
  console.log('Variable is not defined.');
}

The Adventure Continues

The is.primitive and is.not_primitive methods from the 'thiis' package are your reliable companions on your JavaScript adventure. They simplify the process of identifying and working with primitive values, making your code clearer and more robust. By adding the 'thiis' package to your JavaScript toolkit and exploring its documentation for more tips and examples, you can navigate the JavaScript landscape with confidence and a touch of simplicity.

So, keep coding, and enjoy the simplicity of primitives in JavaScript!

DEV Community: Ivan Karbashevskyi

🔁 createSharedPromise: Share In-Flight Async Calls with Elegance

🚀 What Does It Do?

🧠 The Code (fully inline, zero-dependencies)

🧪 Try It Live in DevTools

🧩 Real-World Use Cases

1. 📦 Vanilla Node.js Server

2. 🧱 NestJS Service (shared DB/API calls)

3. 🧩 Angular Service

4. 🌍 Vanilla JS Frontend

✅ Benefits Recap

🧠 Final Thoughts

Unlock the Magic of is.lowerCase and is.not_lowerCase in JavaScript with 'thiis': Your Friendly Guide to String Checks

Embracing Lowercase in JavaScript

Meet is.lowerCase - Your Lowercase Guru

The Tale of Examples

1. Basic Lowercase Validation

2. Guarding Against Lowercase

3. Creative Combos with is.kebabCases_or_lowerCase

4. Stream of Lowercase with is.lowerCase

5. Array Exploration with is.not_lowerCase

6. String Transformation with is.lowerCase

The Adventure Continues

Embracing Clean Code with `is.kebabCase` and `is.not_kebabCase` from 'thiis': A Fun Journey into String Formatting

The Charm of Kebab Case in JavaScript

Meet is.kebabCase - Your String Stylist

The Journey of Examples

1. Checking for Kebab Case

2. Guarding Against Non-Kebab Case

3. Combining with Other Methods

4. Stream of Kebabs with is.kebabCase

5. Array Exploration with is.not_kebabCase

6. Creative URL Validation

7. Additional examples

8. Combination example

The Adventure Continues

Unraveling IPv6 with `is.ipv6` and `is.not_ipv6` in JavaScript: Navigating the Digital Highway

Understanding the IPv6 Landscape

Meet is.ipv6 - Your IPv6 Navigator

The Journey of Examples

1. Validating IPv6 Addresses

2. Guarding Against Non-IPv6 Values

3. Handling IPv6 in Stream$

4. Checking an Array of IP Addresses

5. Additional examples

6. Combination example

The Adventure Continues

Demystifying IP Addresses with is.ipv4 and is.not_ipv4 from 'thiis': Your Friendly Guide to IP Validation

Understanding IPv4 Addresses

Meet is.ipv4 - Your IPv4 Validator

The Grand Tour of Examples

1. Basic IPv4 Validation

2. Guarding Against Non-IPv4 Values

3. Form Validation with is.ipv4

4. Handling IP Address Arrays

5. Stream of IPv4 Addresses

6. Mixing IPv4 and Non-IPv4 in an Array

7. Additional examples

The Adventure's Conclusion

Discover the Charm of is.char and is.not_char in JavaScript with 'thiis'

Unveiling the Magic of Characters in JavaScript

Meet is.char - Your Character Connoisseur

The Charmed Examples

1. Checking a Single Character

2. Guarding Against Non-Characters

3. Charmed Validation Function

4. Charming Array Exploration

5. Charmed Stream of Characters

6. Checking Charming User Input

The Charmed Conclusion

Unraveling the Mystery of is.camelCase with 'thiis': Your Guide to JavaScript Naming Conventions

Understanding the Elegance of CamelCase in JavaScript

Meet is.camelCase - Your CamelCase Validator

The Journey of Examples

1. Checking Variable Names

2. Guarding Function Names

3. Validating User Input

4. Conditional Styling in CSS

5. Stream of Style with is.camelCase

6. Array Exploration with is.not_camelCase

Meet `is.lowerCase` - Your Lowercase Guru

3. Creative Combos with `is.kebabCases_or_lowerCase`

4. Stream of Lowercase with `is.lowerCase`

5. Array Exploration with `is.not_lowerCase`

6. String Transformation with `is.lowerCase`

Meet `is.kebabCase` - Your String Stylist

4. Stream of Kebabs with `is.kebabCase`

5. Array Exploration with `is.not_kebabCase`

Meet `is.ipv6` - Your IPv6 Navigator

Meet `is.ipv4` - Your IPv4 Validator

3. Form Validation with `is.ipv4`

Meet `is.char` - Your Character Connoisseur

Meet `is.camelCase` - Your CamelCase Validator

5. Stream of Style with `is.camelCase`

6. Array Exploration with `is.not_camelCase`

Meet `is.promise` - Your Promise Whisperer

1. Chasing Async Dreams with `is.promise`

2. Guardian of Non-Promises - `is.not_promise`

4. Magical Streams with `is.promise`

5. Array Adventures with `is.not_promise`

Meet `is.null` - Your Null Navigator

3. Validating Inputs with `is.null`

4. Robust Conditionals with `is.not_null`

5. Stream of Clarity with `is.null`

6. Array Exploration with `is.not_null`

Meet `is.symbol` - Your Symbolic Guide

The Enigmatic World of `undefined` in JavaScript

Meet `is.undefined` - Your Undefined Navigator

5. Navigating Streams with `is.undefined`

6. Array Exploration with `is.not_undefined`

Meet `is.primitive` - Your Guide to Simplicity

4. Array Exploration with `is.not_primitive`

5. Simple Math with `is.primitive`

6. Checking for `undefined`