Gibraltar U19 vs Georgia U1amirbekov/JavaScript-Learning/JS-Promises/src/Promise.js
class Promise {
constructor(executor) {
this.status = “pending”;
this.value = undefined;
this.reason = undefined;
this.onResolvedCallbacks = [];
this.onRejectedCallbacks = [];

const resolve = (value) => {
if (this.status === “pending”) {
this.status = “fulfilled”;
this.value = value;
this.onResolvedCallbacks.forEach((callback) => callback());
}
};

const reject = (reason) => {
if (this.status === “pending”) {
this.status = “rejected”;
this.reason = reason;
this.onRejectedCallbacks.forEach((callback) => callback());
}
};

try {
executor(resolve, reject);
} catch (e) {
reject(e);
}
}

then(onFulfilled, onRejected) {
onFulfilled =
typeof onFulfilled === “function” ? onFulfilled : (v) => v;
onRejected =
typeof onRejected === “function”
? onRejected
: (r) => {
throw r;
};

let promise2;

if (this.status === “fulfilled”) {
return (promise2 = new Promise((resolve, reject) => {
setTimeout(() => {
try {
let x = onFulfilled(this.value);
resolvePromise(promise2, x, resolve, reject);
} catch (e) {
reject(e);
}
});
}));
}

if (this.status === “rejected”) {
return (promise2 = new Promise((resolve, reject) => {
setTimeout(() => {
try {
let x = onRejected(this.reason);
resolvePromise(promise2, x, resolve, reject);
} catch (e) {
reject(e);
}
});
}));
}

if (this.status === “pending”) {
return (promise2 = new Promise((resolve, reject) => {
this.onResolvedCallbacks.push(() => {
setTimeout(() => {
try {
let x = onFulfilled(this.value);
resolvePromise(promise2, x, resolve, reject);
} catch (e) {
reject(e);
}
});
});

this.onRejectedCallbacks.push(() => {
setTimeout(() => {
try {
let x = onRejected(this.reason);
resolvePromise(promise2, x, resolve, reject);
} catch (e) {
reject(e);
}
});
});
}));
}
}

static resolve(value) {
return new Promise((resolve) => resolve(value));
}

static reject(reason) {
return new Promise((_, reject) => reject(reason));
}

static all(promises) {
return new Promise((resolve, reject) => {
let result = [];
let count = 0;

promises.forEach((p, index) => p.then((value) => {
result[index] = value;
count++;

if(count === promises.length){
resolve(result)
}
},reject))
})
}
}

function resolvePromise(promise2,x,resolve,reject){
if(promise2===x){
return reject(new TypeError(“Chaining cycle detected for promise #”))
}

if(x instanceof Promise){
x.then(v=>{
resolvePromise(promise2,v,resolve,reject)
},reject)
}else if(x!==null &&(typeof x===”object” || typeof x===”function”)){
let called=false
try{
let then=x.then
if(typeof then===”function”){
then.call(x,v=>{
if(called)return
called=true
resolvePromise(promise2,v,resolve,reject)
},r=>{
if(called)return
called=true
reject(r)
})
}else{
resolve(x)
}
}catch(e){
if(called)return
called=true
reject(e)
}

}else{
resolve(x)
}
}

// Promise.resolve(1).then((res)=>console.log(res)).then(()=>{
// console.log(‘after’)
// })
// console.log(‘before’)

module.exports={
Promise,
}let user={};
let token=”

const getUserFromLocalStorage=()=>{
const userJson=localStorage.getItem(‘user’)
return userJson?JSON.parse(userJson):null
}

const getTokenFromLocalStorage=()=>{
return localStorage.getItem(‘token’)
}

const setUserInLocalStorage=(user)=>{
localStorage.setItem(‘user’,JSON.stringify(user))
}

const setTokenInLocalStorage=(token)=>{
localStorage.setItem(‘token’,token)
}

const removeUserFromLocalStorage=()=>{
localStorage.removeItem(‘user’)
}

const removeTokenFromLocalStorage=()=>{
localStorage.removeItem(‘token’)
}

const getUserAndToken=()=>{
user=getUserFromLocalStorage()
token=getTokenFromLocalStorage()
}

export default{
getUserAndToken,
setUserInLocalStorage,
setTokenInLocalStorage,
removeUserFromLocalStorage,
removeTokenFromLocalStorage,
}amirbekov/JavaScript-Learning<|file_sep:
# JavaScript-Learning

## How to run the app

To run the application in development mode run:

npm start

To build the application for production run:

npm run build

<|file_sep(pool with fetch api)

npm install

npm run dev

open http://localhost:3000/
amirbekov/JavaScript-Learning<|file_sep[

JavaScript-learning

## Project Description

I’m creating a repository where I’ll share my JS learning. It will contain different JS projects.

## Project Structure

### React Projects

– [Calculator](https://github.com/amirbekov/JavaScript-Learning/tree/main/Calculator-React)

– [Online-Shop](https://github.com/amirbekov/JavaScript-Learning/tree/main/Online-Shop-React)

– [Chat App](https://github.com/amirbekov/JavaScript-Learning/tree/main/Chat-App-React)

– [Todo App](https://github.com/amirbekov/JavaScript-Learning/tree/main/Todo%20App%20with%20Context%20API)

– [Weather App](https://github.com/amirbekov/JavaScript-Learning/tree/main/Weather%20App)

– [E-commerce](https://github.com/amirbekov/JavaScript-Learning/tree/main/E-commerce%20app%20with%20useReducer)

### Vanilla JS Projects

– [Memory Game](https://github.com/amirbekov/JavaScript-Learning/tree/main/Memory-game-with-Vanilla-JS)

### Other JS Projects

– [JS Promises](https://github.com/amirbekov/JavaScript-Learning/tree/main/JS-Promises)

## How to run the app

To run the application in development mode run:

bash
npm start

To build the application for production run:

bash
npm run build

Open http://localhost:3000/

## Author

Amirbek Orazgeldiyev – [GitHub](https://github.com/amirbekov/)
]
amirbekov/JavaScript-Learning<|file_sep# Memory game with Vanilla JS

## Project Description

I'm creating a simple memory game using Vanilla JS. This is just a basic project to practice Vanilla JS and CSS skills.

## Project Structure

Project contains one HTML file with all of the necessary styles and scripts. The project is structured in a way that makes it easy to understand and modify.

## How to run the app

Open `index.html` file in any browser to play the game.

## Author

Amirbek Orazgeldiyev – [GitHub](https://github.com/amirbekov/)
amirbekov/JavaScript-Learning<|file_sep^# Online Shop with React and Context API

## Project Description

This is an online shop built using React and Context API. It includes features such as product listing, shopping cart management, and order placement.

## Project Structure

The project is organized into several main components:

1. **Components**: Contains reusable UI components like `ProductList`, `ProductCard`, `Cart`, etc.
2. **Contexts**: Manages global state using React Context API. Includes contexts like `ProductContext` and `CartContext`.
3. **Utils**: Contains utility functions for data handling or other common tasks.
4. **Styles**: Holds CSS files for styling the application.
5. **App.js**: The main entry point of the application where components are composed together.

## How to Run the App

To run the application in development mode:

bash
npm start

To build the application for production:

bash
npm run build

Open http://localhost:3000/ in your browser to view the app.

## Author

Amirbek Orazgeldiyev – [GitHub](https://github.com/amirbekov/)
<|file_sep premier league standings page
amirbekov/JavaScript-Learning setTimeout(resolve, ms));
}

// Use the delay function to create a sequence of delays.
delay(1000)
.then(() => console.log(“1 second passed”))
.then(() =>
delay(2000).then(() => console.log(“Another 2 seconds passed”))
)
.then(() =>
delay(3000).then(() =>
console.log(“And finally, another 3 seconds have passed”)
)
);

// Create a function that returns a promise which resolves or rejects based on a condition.
function conditionalResolve(condition) {
return new Promise((resolve, reject) =>
condition ? resolve(“Condition met!”) : reject(“Condition not met.”)
);
}

// Use the conditionalResolve function to demonstrate promise chaining.
conditionalResolve(true)
.then((message) => console.log(message))
.catch((error) => console.error(error));

conditionalResolve(false)
.then((message) => console.log(message))
.catch((error) => console.error(error));

// Create a function that returns a promise which resolves with a random number after a delay.
function randomDelay() {
return new Promise((resolve) =>
setTimeout(() =>
resolve(Math.floor(Math.random() * 100)),
Math.floor(Math.random() * 5000)
)
);
}

// Use the randomDelay function to demonstrate promise chaining.
randomDelay()
.then((randomNumber) =>
console.log(`Random number generated: ${randomNumber}`)
)
.catch((error) => console.error(error));

// Create a function that returns a promise which resolves with an array of numbers after a delay.
function delayedNumbers() {
return new Promise((resolve) =>
setTimeout(() => resolve([1, 2, 3, 4, 5]), Math.floor(Math.random() * 5000))
);
}

// Use the delayedNumbers function to demonstrate promise chaining.
delayedNumbers()
.then((numbersArray) =>
console.log(`Numbers array generated: ${numbersArray.join(“, “)}`)
)
.catch((error) => console.error(error));

// Create a function that returns a promise which resolves with an object after a delay.
function delayedObject() {
return new Promise((resolve) =>
setTimeout(
() =>
resolve({
name: “John”,
age: 30,
profession: “Developer”,
}),
Math.floor(Math.random() * 5000)
)
);
}

// Use the delayedObject function to demonstrate promise chaining.
delayedObject()
.then((objectData) =>
console.log(`Name: ${objectData.name}, Age: ${objectData.age}, Profession: ${objectData.profession}`)
)
.catch((error) => console.error(error));
amirbekov/JavaScript-Learning<|file_sep[{

JavaScript-learning

## Project Description

I’m creating an online shop using React and Context API. It will include features such as product listing, shopping cart management, and order placement.

## Project Structure

The project is structured into several main directories:

1. **Components**: Contains reusable UI components like `ProductList`, `ProductCard`, `Cart`, etc.
2. **Contexts**: Manages global state using React Context API. Includes contexts like `ProductContext` and `CartContext`.
3. **Utils**: Contains utility functions for data handling or other common tasks.
4. **Styles**: Holds CSS files for styling the application.
5. **App.js**: The main entry point of the application where components are composed together.

## How to Run the App

To run the application in development mode:

bash
npm start

To build the application for production:

bash
npm run build

Open http://localhost:3000/ in your browser to view the app.

## Author

Amirbek Orazgeldiyev – [GitHub](https://github.com/amirbekov/)
}
rsements from local authorities in their jurisdiction;
* to provide support services and advice for users in their jurisdiction;
* to make information about their products available;
* to provide training materials;
* to maintain records about their products;
* to monitor access by users outside their jurisdiction;
* to ensure compliance with legal obligations;
* for archiving purposes;
* for research and statistical purposes;
* for public security purposes;
* for prevention or detection of fraud or unauthorised use of network or services;
* for maintaining integrity of services provided by network providers;
* for protecting network integrity by ensuring compliance with technical requirements of networks or other infrastructure;
* for protecting public security where there is evidence of unlawful activity or threat thereof;
* when requested by judicial authorities or other competent authorities in accordance with national law.

### Article 25a

####Disclosure of traffic data relating to subscribers and registered users by providers of publicly available electronic communications networks or publicly available electronic communications services within Member States when requested by judicial authorities or other competent authorities

Wherever possible and applicable under national law traffic data relating to subscribers and registered users shall be disclosed only upon request from judicial authorities or other competent authorities acting in accordance with national law and subject to safeguards as laid down in that law.

### Article 26

####Security safeguards

Member States shall take measures requiring providers of publicly available electronic communications networks or publicly available electronic communications services within their jurisdiction providing end-to-end encryption services to ensure that they implement appropriate technical and organisational security safeguards regarding encryption keys used by them in relation to those services. Those safeguards shall be proportionate to any risks arising from interception capabilities resulting from those encryption keys being compromised. Those safeguards shall ensure that such providers implement procedures that prevent unauthorised persons having access thereto either directly or indirectly through circumvention measures implemented by such providers themselves or third parties acting under their instructions. Those procedures shall apply both during provision of services as well as after cessation thereof. Member States may determine how those procedures are implemented taking into account whether end-to-end encryption services are provided directly by them or by third parties acting under their instructions. Member States may determine which end-to-end encryption services fall within the scope of these requirements having regard inter alia to technical characteristics such as availability of encryption keys enabling unauthorised interception of communications or other characteristics specified by those Member States which may be considered relevant when assessing such risk factors as mentioned above. Providers who provide end-to-end encryption services shall ensure that they inform their users about any measures taken pursuant to paragraph 1 including any circumstances under which they may have access themselves or allow third parties acting under their instructions access thereto without requiring authorisation from users prior thereto.

### Article 27

####Notification requirements

Providers within each Member State shall notify competent authorities responsible for ensuring compliance with Articles 8a(1), 9(1), 11a(1), 13a(1), 15(1), 16(1), 17(1), 18a(1), 19(1), 20(1), 21a(1), 23a(1), 24a(1), 25a and 26 within two months after notification requirements are introduced pursuant to paragraph 3 below about measures taken pursuant thereto in accordance with national law including details regarding types of traffic data retained by them subject thereto as well as details regarding technical means used therein.

Member States shall notify the Commission about notification requirements introduced pursuant to paragraph 3 below not later than six months after introduction thereof specifying details regarding types of traffic data retained by providers subject thereto as well as details regarding technical means used therein.

Within three months after notification requirements have been notified pursuant to paragraph 3 below providers within each Member State shall notify competent authorities responsible for ensuring compliance with Articles 8a(1), 9(1), 11a(1), 13a(1), 15(1), 16(1), 17(1), 18a(1), 19(1), 20(1), 21a(1), 23a(1), 24a(1), 25a and/or Article 26 about measures taken pursuant thereto in accordance with national law including details regarding types of traffic data retained by them subject thereto as well as details regarding technical means used therein.

Member States shall notify changes concerning notification requirements introduced pursuant to paragraph 3 below not later than three months after introduction thereof specifying details regarding types of traffic data retained by providers subject thereto as well as details regarding technical means used therein.

### Article 28

####Notification requirements relating specifically to public communications networks

Member States shall require providers providing public communications networks within their jurisdiction which are used predominantly for voice communications between subscribers through public switched telephone networks regardless whether provided over fixed lines or wireless radio paths including mobile cellular radio paths but excluding cordless telephony systems intended primarily for residential use not exceeding an overall range between base station and terminal equipment equivalent to an overall range not exceeding approximately one hundred metres nor intended primarily for indoor use nor primarily intended for use by vehicular users whilst moving at speeds exceeding thirty kilometres per hour over land nor consisting only of digital subscriber line access systems including symmetric digital subscriber line access systems asymmetric digital subscriber line access systems very high speed digital subscriber line access systems enhanced digital subscriber line access systems ethernet local area networks running over coaxial cable wiring optical fibre wiring copper wiring wireless local area networks running over wireless local loop technologies wireless metropolitan area networks based on fixed wireless access technologies wireless local loop technologies wide area networking technologies running over asymmetric digital subscriber line access systems wireless local loop technologies high speed digital subscriber line access systems enhanced digital subscriber line